Classification.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Classification.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "zPHa8_VMRD4L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import math\n",
        "from sklearn.preprocessing import normalize\n",
        "from sklearn.decomposition import PCA\n",
        "from sklearn.model_selection import KFold\n",
        "from statistics import mode\n",
        "from sklearn.metrics import confusion_matrix\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHN-S8i5Sz7F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def kNearestNeighbor(trainData, testData, K=1):\n",
        "  classColumnNum = trainData.shape[1]\n",
        "  trainDataSize = len(trainData)\n",
        "  testDataSize = len(testData)\n",
        "  EuclideanDis = np.zeros((testDataSize, trainDataSize))\n",
        "  for i in range(testDataSize):\n",
        "    for j in range(trainDataSize):\n",
        "      EuclideanDis[i,j] = np.linalg.norm(testData[i,0:classColumnNum-1]-trainData[j,0:classColumnNum-1])\n",
        "\n",
        "  predicted = np.zeros(testDataSize)\n",
        "  sample = np.zeros((2,trainDataSize))\n",
        "  sample[1,:] = trainData[:,-1]\n",
        "  for p in range(testDataSize):\n",
        "    sample[0,:] = EuclideanDis[p,:]\n",
        "    s_sample = sample[:, np.argsort(sample[0, :])]\n",
        "    if K==1:\n",
        "      predicted[p] = s_sample[1,p]\n",
        "    else:\n",
        "      predicted[p] = mode(s_sample[1,:K])\n",
        "  \n",
        "  return confusion_matrix(testData[:,-1].astype(float), predicted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VL6_8ylIacLP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def minimumMeanDistance(trainData, testData):\n",
        "  classColumnNum = trainData.shape[1]\n",
        "  trainDataSize = len(trainData)\n",
        "  testDataSize = len(testData)\n",
        "  allClasses = list(set(trainData[:,-1]))\n",
        "  eachClassMeanEucDis = np.zeros(len(allClasses))\n",
        "  EuclideanDis = np.zeros((len(allClasses), testDataSize, trainDataSize))\n",
        "  predicted = np.zeros(testDataSize)\n",
        "  for i in range(testDataSize):\n",
        "    for j in range(trainDataSize):\n",
        "      for k in allClasses:\n",
        "        if trainData[j,-1] == k:\n",
        "          EuclideanDis[k,i,j] = np.linalg.norm(testData[i,0:classColumnNum-1]-trainData[j,0:classColumnNum-1])\n",
        "    for l in allClasses:\n",
        "      eachClassMeanEucDis[l] = EuclideanDis[l,i].sum()/np.count_nonzero(EuclideanDis[l,i])\n",
        "    predicted[i] = np.argmin(eachClassMeanEucDis)\n",
        "  \n",
        "  return confusion_matrix(testData[:,-1].astype(float), predicted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1NSTFTOik-VX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def gaussianDestributionBayes(trainData, testData, risk=False):\n",
        "  allClasses = list(set(trainData[:,-1]))\n",
        "  separatedByClass = {}\n",
        "  for i in allClasses:\n",
        "    separatedByClass[i] = trainData[trainData[:,-1] == i, :-1]\n",
        "\n",
        "  allMeanSTD = {}\n",
        "  for classLabel, instances in separatedByClass.items():\n",
        "    mean_std = [(np.mean(attribute), np.std(attribute)) for attribute in zip(*instances)]\n",
        "    allMeanSTD[classLabel] = mean_std\n",
        "\n",
        "  if risk:\n",
        "    Lambda = np.zeros(len(allClasses))\n",
        "    Lambda[0] = 0.98\n",
        "    Lambda[1] = 1.08\n",
        "\n",
        "  predicted = np.zeros(len(testData))\n",
        "  for i in range(len(testData)):\n",
        "    probabilities = {}\n",
        "    for classLabel, classAllMeanSTD in allMeanSTD.items():\n",
        "      # probabilities[classLabel] = 1\n",
        "      probabilities[classLabel] = len(separatedByClass[classLabel])/len(trainData)\n",
        "      for j in range(len(classAllMeanSTD)):\n",
        "        mean, stdev = classAllMeanSTD[j]\n",
        "        exponent = math.exp(-(math.pow(testData[i,j]-mean,2)/(2*math.pow(stdev,2))))\n",
        "        if risk:\n",
        "          probabilities[classLabel] *= Lambda[classLabel] * (1/(math.sqrt(2*math.pi)*stdev))*exponent\n",
        "        else:\n",
        "          probabilities[classLabel] *= (1/(math.sqrt(2*math.pi)*stdev))*exponent\n",
        "    bestLabel, bestProb = None, -1\n",
        "    for classLabel, probability in probabilities.items():\n",
        "      if bestLabel is None or probability > bestProb:\n",
        "        bestProb = probability\n",
        "        bestLabel = classLabel\n",
        "    predicted[i] = bestLabel\n",
        "    \n",
        "  return confusion_matrix(testData[:,-1].astype(float), predicted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s9I5skpWsTjj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def supportVectorMachine(trainData, testData):\n",
        "  W = np.zeros(np.size(trainData,1)-1)\n",
        "  predicted = []\n",
        "  for i,v in enumerate(trainData[:,-1]):\n",
        "    if v==0:\n",
        "      trainData[i,-1] = 1\n",
        "    else:\n",
        "      trainData[i,-1] = -1\n",
        "\n",
        "  for i, val in enumerate(trainData[:,:-1]):\n",
        "    val1 = np.dot(trainData[i,:-1], W)\n",
        "    if (trainData[i,-1]*val1 < 1):\n",
        "      W = W + ((trainData[i,-1]*trainData[i,:-1]) - (2*W))\n",
        "    else:\n",
        "      W = W + (-2*W)\n",
        "\n",
        "  for i, val in enumerate(testData[:,:-1]):\n",
        "    predicted.append(np.dot(testData[i,:-1], W))\n",
        "\n",
        "  for i,v in enumerate(predicted):\n",
        "    if np.sign(v) == 1:\n",
        "      predicted[i] = 0\n",
        "    else:\n",
        "      predicted[i] = 1\n",
        "\n",
        "  return confusion_matrix(testData[:,-1].astype(float), predicted)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6a9-2nkRbx0F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Reading Data and Preprocessing\n",
        "data_dir = '/content/gdrive/My Drive/Colab Notebooks/Dataset/'\n",
        "df=pd.read_csv(data_dir + 'Cancer.csv', sep=',',header=None)\n",
        "data = np.asarray(df)\n",
        "data = np.delete(data, 0, 0)\n",
        "data = np.delete(data, 0, 1)\n",
        "data = np.delete(data, (data.shape[1]-1), 1)\n",
        "data[:,[-1,0]] = data[:,[0,-1]]\n",
        "data[:,:-1] = data[:,:-1].astype(np.float)\n",
        "data[:,:-1] = normalize(data[:,:-1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bw0ttKTmgkRy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Principle Compnents Analysis\n",
        "pca = PCA(n_components=20)\n",
        "class_column = data.shape[1]\n",
        "n_data = pca.fit_transform(data[:,0:class_column-2])\n",
        "labels = data[:, -1:]\n",
        "data_DR = np.append(n_data, labels, axis=1)\n",
        "le = LabelEncoder()\n",
        "le.fit(data_DR[:,-1])\n",
        "data_DR[:,-1] = le.transform(data_DR[:,-1])\n",
        "data_DR[:,-1] = data_DR[:,-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sRWHvhBFoso_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 521
        },
        "outputId": "f4e38b1e-b5e3-433e-d460-0101cfa7c664"
      },
      "source": [
        "#K-Fold Cross Validation\n",
        "numOfMethods = 5\n",
        "folds = 5\n",
        "kf = KFold(n_splits=folds)\n",
        "CM = np.zeros((numOfMethods,2,2))\n",
        "TPR = np.zeros(numOfMethods)\n",
        "FPR = np.zeros(numOfMethods)\n",
        "\n",
        "for train, test in kf.split(data_DR):\n",
        "  trainData = []\n",
        "  testData = []\n",
        "  for i in train:\n",
        "    trainData.append(data_DR[i])\n",
        "  for j in test:\n",
        "    testData.append(data_DR[j]) \n",
        "  trainData = np.asarray(trainData)\n",
        "  testData = np.asarray(testData)\n",
        "\n",
        "  nameOfMethods = {0: [kNearestNeighbor(trainData, testData, K=1), 'KNN'],\n",
        "                   1: [minimumMeanDistance(trainData, testData), 'Min Mean Dis'],\n",
        "                   2: [gaussianDestributionBayes(trainData, testData), 'Gaussian Bayes'],\n",
        "                   3: [gaussianDestributionBayes(trainData, testData, risk=True), 'Gaussian Bayes (Conditional Risk)'],\n",
        "                   4: [supportVectorMachine(trainData, testData), 'SVM']}\n",
        "\n",
        "  #Classification\n",
        "  for z in range(0,numOfMethods):\n",
        "    CM[z] += nameOfMethods[z][0]\n",
        "\n",
        "for z in range(0,numOfMethods):\n",
        "  print(z)\n",
        "  CM[z] = np.round(CM[z]/folds)\n",
        "  print('Confusion Matrix of ', nameOfMethods[z][1], ' Method')\n",
        "  print(CM[z])\n",
        "  print(nameOfMethods[z][1], 'Accuracy: ', (CM[z][0][0]+CM[z][1][1])/(sum(CM[z][0])+sum(CM[z][1])), '%')\n",
        "  print('')\n",
        "  TPR[z] = CM[z][0][0]/sum(CM[z][0])\n",
        "  FPR[z] = CM[z][1][0]/sum(CM[z][1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "Confusion Matrix of  KNN  Method\n",
            "[[65.  6.]\n",
            " [13. 29.]]\n",
            "KNN Accuracy:  0.831858407079646 %\n",
            "\n",
            "1\n",
            "Confusion Matrix of  Min Mean Dis  Method\n",
            "[[70.  1.]\n",
            " [ 9. 33.]]\n",
            "Min Mean Dis Accuracy:  0.911504424778761 %\n",
            "\n",
            "2\n",
            "Confusion Matrix of  Gaussian Bayes  Method\n",
            "[[61. 11.]\n",
            " [ 5. 37.]]\n",
            "Gaussian Bayes Accuracy:  0.8596491228070176 %\n",
            "\n",
            "3\n",
            "Confusion Matrix of  Gaussian Bayes (Conditional Risk)  Method\n",
            "[[42. 30.]\n",
            " [ 3. 39.]]\n",
            "Gaussian Bayes (Conditional Risk) Accuracy:  0.7105263157894737 %\n",
            "\n",
            "4\n",
            "Confusion Matrix of  SVM  Method\n",
            "[[49. 22.]\n",
            " [ 8. 34.]]\n",
            "SVM Accuracy:  0.7345132743362832 %\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_emZnmUl7K1G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 350
        },
        "outputId": "fb2d1814-4e2d-4050-dc74-3f5855e35c45"
      },
      "source": [
        "#ROC Plot\n",
        "plt.figure(figsize=[10, 5])\n",
        "for z in range(0,numOfMethods):\n",
        "  plt.plot(FPR[z]+0.001, TPR[z]+0.001, 'o' , markersize=5, label=(nameOfMethods[z][1] +  \" Classifier\"))\n",
        "plt.plot([0, 1], [0, 1], color='navy', linestyle='--', label = \"Random Classifier\")\n",
        "plt.xlim([0.0, 1.0])\n",
        "plt.ylim([0.0, 1.0])\n",
        "plt.xlabel('False Positive Rate')\n",
        "plt.ylabel('True Positive Rate')\n",
        "plt.title('Receiver Operating Characteristic Plot')\n",
        "plt.legend(loc=\"lower right\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}