06. Dimentionality Reduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimentionality Reduction\n",
    "- used to reduce number of feature\n",
    "- two types: Feature Selection & Feature Extraction  \n",
    "\n",
    "Advantages:  \n",
    "- less space is required\n",
    "- less computation time\n",
    "- takes care of multicollinearity by removing redundant features(e.g: kg & gms)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Feature Selection Techiniques\n",
    "By only keeping the most relevant variables from the original dataset\n",
    "\n",
    "- Backward Feature Elimination (Start removing one variable each time and check performance)\n",
    "- Forward Feature Selection (Start with one variable and see which is best)\n",
    "- Random Forest (comes packaged with in-built feature importance)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Common Feature Extraction Techiniques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Principal Component Analysis (PCA)\n",
    "- extracting a new set of variables(Principal Components) from existing large set\n",
    "- Principal Components are linear combination of original set\n",
    "- linear dimensionality reduction or feature selection technique\n",
    "- unsupervised algorithm as it ignores Dependent Variable and goal is to find the direction\n",
    "- its a projection of a higher-dimensional space into a lower dimensional space while preserving as much information as possible\n",
    "- remove feature that explains less % of variance\n",
    "\n",
    "<img src=\"Image/pca1.jpg\" width=\"400\" />\n",
    "<img src=\"Image/pca2.jpg\" width=\"400\" />\n",
    "\n",
    "<a href=\"https://stats.stackexchange.com/questions/2691/making-sense-of-principal-component-analysis-eigenvectors-eigenvalues\">More read</a>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.37281068 0.18739996]\n"
     ]
    }
   ],
   "source": [
    "#Take the full code from Logistic Regression and modify the import dataset X & y to include more features\n",
    "# Importing the libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "# Importing the dataset - https://archive.ics.uci.edu/ml/datasets/wine\n",
    "dataset = pd.read_csv('Data/Dimensionality/Wine.csv')\n",
    "X = dataset.iloc[:, 0:13].values\n",
    "y = dataset.iloc[:, 13].values\n",
    "\n",
    "X = X.astype(float)\n",
    "y = y.astype(float)\n",
    "\n",
    "# Splitting the dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "\n",
    "# Perform Feature Scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "## Applying PCA\n",
    "from sklearn.decomposition import PCA\n",
    "#pca = PCA(n_components = None), In case to check the variance of each independent variable\n",
    "pca = PCA(n_components = 2)\n",
    "X_train = pca.fit_transform(X_train)\n",
    "X_test = pca.transform(X_test)\n",
    "explained_variance = pca.explained_variance_ratio_\n",
    "print(explained_variance)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9624060150375939\n",
      "[[16  0  0]\n",
      " [ 1 20  0]\n",
      " [ 0  0  8]]\n"
     ]
    }
   ],
   "source": [
    "#Apply Logic Regresson after reducing the features\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import metrics\n",
    "# import warnings filter\n",
    "from warnings import simplefilter\n",
    "# ignore all future warnings\n",
    "simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "lr_model =LogisticRegression(C=0.7, random_state=42)\n",
    "lr_model.fit(X_train, y_train.ravel())\n",
    "lr_predict_test = lr_model.predict(X_test)\n",
    "print(lr_model.score(X_train,y_train))\n",
    "\n",
    "# Making the Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test, lr_predict_test)\n",
    "print(cm)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "#Define Variables\n",
    "clf = lr_model\n",
    "h = 0.1\n",
    "X_plot, z_plot = X_train, y_train \n",
    "\n",
    "#Template for all Regression\n",
    "x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1\n",
    "y_min, y_max = X_plot[:, 1].min() - 1, X_plot[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "\n",
    "# Plot the decision boundary. For that, we will assign a color to each\n",
    "# point in the mesh\n",
    "Z = clf.predict(np.array([xx.ravel(), yy.ravel()]).T)\n",
    "Z = Z.reshape(xx.shape)\n",
    "plt.contourf(xx, yy, Z,\n",
    "             alpha = 0.7, cmap = ListedColormap(('blue', 'red', 'green')))\n",
    "\n",
    "\n",
    "for i, j in enumerate(np.unique(z_plot)):\n",
    "    plt.scatter(X_plot[z_plot == j, 0], X_plot[z_plot == j, 1],\n",
    "                c = ['blue', 'red', 'green'][i], cmap = ListedColormap(('blue', 'red', 'green')), label = j)\n",
    "   #X[:, 0], X[:, 1] \n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "plt.title('Logistic Regression After PCA')\n",
    "plt.xlabel('Independent Variable 1')\n",
    "plt.ylabel('Independent Variable 2')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### How to Choose the Number of Components\n",
    "\n",
    "But how much information have we thrown away? We can check this  by looking at the explained variance as a function of the components:\n",
    "- We just need 4 Features to explain 80% of Variance in the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#np.cumsum -> cumulative sum of array elements\n",
    "plt.plot(np.cumsum(pca.explained_variance_ratio_))\n",
    "plt.xlabel('Number of Components')\n",
    "plt.ylabel('Cumulative Explained Variance');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Issue with PCA\n",
    "1. Measurements from all of the original variables are used in the projection to the lower dimensional space\n",
    "2. Only linear relationships are considered\n",
    "3. Do not consider the potential multivariate nature of the data structure (higher order interaction between variables)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to Address above issues?\n",
    "1. Feature Selection Techiniques can be used\n",
    "2. Kernel PCA - to embed nonlinear relationships into a lower dimensional space\n",
    "3. Random Forest or Decision Tree. Random Forest derive Gini- or permutation-based measures of feature importance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Advantages of PCA\n",
    "- Improves performance of Algorithm(less feature)\n",
    "- Help in removing correlated feature\n",
    "- Reduces overfitting\n",
    "- Reduce Training time\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using other dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import Libraries\n",
    "import pandas as pd                 # pandas is a dataframe library\n",
    "import matplotlib.pyplot as plt      # matplotlib.pyplot plots data\n",
    "%matplotlib inline\n",
    "\n",
    "#Read the data\n",
    "df = pd.read_csv(\"Data/Classification/pima-data.csv\")\n",
    "\n",
    "#Check the Correlation\n",
    "df.corr()\n",
    "#Delete the correlated feature\n",
    "del df['skin']\n",
    "\n",
    "#Data Molding\n",
    "diabetes_map = {True : 1, False : 0}\n",
    "df['diabetes'] = df['diabetes'].map(diabetes_map)\n",
    "\n",
    "#Splitting the data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "#This will copy all columns from 0 to 7(8 - second place counts from 1)\n",
    "X = df.iloc[:, 0:8]\n",
    "y = df.iloc[:, 8]\n",
    "\n",
    "split_test_size = 0.30\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split_test_size, random_state=42) \n",
    "\n",
    "#Imputing\n",
    "from sklearn.impute import SimpleImputer \n",
    "\n",
    "#Impute with mean all 0 readings\n",
    "fill_0 = SimpleImputer(missing_values=0, strategy=\"mean\")\n",
    "\n",
    "X_train = fill_0.fit_transform(X_train)\n",
    "X_test = fill_0.fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.29139538 0.17448845]\n"
     ]
    }
   ],
   "source": [
    "# Perform Feature Scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "# Applying PCA\n",
    "from sklearn.decomposition import PCA\n",
    "#pca = PCA(n_components = None), In case to check the variance of each independent variable\n",
    "pca = PCA(n_components = 2)\n",
    "X_train = pca.fit_transform(X_train)\n",
    "X_test = pca.transform(X_test)\n",
    "explained_variance = pca.explained_variance_ratio_\n",
    "print(explained_variance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7393\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Training with Naive Bayes\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "\n",
    "# create Gaussian Naive Bayes model object and train it with the data\n",
    "nb_model = GaussianNB()\n",
    "\n",
    "nb_model.fit(X_train, y_train.ravel())\n",
    "# Calculate Accuracy on training data\n",
    "# predict values using the training data\n",
    "nb_predict_train = nb_model.predict(X_train)\n",
    "\n",
    "# import the performance metrics library\n",
    "from sklearn import metrics\n",
    "\n",
    "# Accuracy\n",
    "print(\"Accuracy: {0:.4f}\".format(metrics.accuracy_score(y_train, nb_predict_train)))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "import numpy as np\n",
    "#Define Variables\n",
    "clf = nb_model\n",
    "h = 0.1\n",
    "X_plot, z_plot = X_train, y_train \n",
    "\n",
    "#Template for all Regression\n",
    "x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1\n",
    "y_min, y_max = X_plot[:, 1].min() - 1, X_plot[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "\n",
    "# Plot the decision boundary. For that, we will assign a color to each\n",
    "# point in the mesh\n",
    "Z = clf.predict(np.array([xx.ravel(), yy.ravel()]).T)\n",
    "Z = Z.reshape(xx.shape)\n",
    "plt.contourf(xx, yy, Z,\n",
    "             alpha = 0.7, cmap = ListedColormap(('blue', 'red')))\n",
    "\n",
    "\n",
    "for i, j in enumerate(np.unique(z_plot)):\n",
    "    plt.scatter(X_plot[z_plot == j, 0], X_plot[z_plot == j, 1],\n",
    "                c = ['blue', 'red'][i], cmap = ListedColormap(('blue', 'red')), label = j)\n",
    "   #X[:, 0], X[:, 1] \n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "plt.title('Naive Bayes After PCA')\n",
    "plt.xlabel('Independent Variable 1')\n",
    "plt.ylabel('Independent Variable 2')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Linear Discriminant Analysis <a href=\"https://medium.com/machine-learning-researcher/dimensionality-reduction-pca-and-lda-6be91734f567\">(LDA)</a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.74784132 0.25215868]\n"
     ]
    }
   ],
   "source": [
    "# Importing the libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "\n",
    "# Importing the dataset\n",
    "dataset = pd.read_csv('Data\\Dimensionality\\Wine.csv')\n",
    "X = dataset.iloc[:, 0:13].values\n",
    "y = dataset.iloc[:, 13].values\n",
    "\n",
    "X = X.astype(float)\n",
    "y = y.astype(float)\n",
    "\n",
    "# Splitting the dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n",
    "\n",
    "# Perform Feature Scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "# Applying LDA\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "lda = LDA(n_components = 2)\n",
    "X_train = lda.fit_transform(X_train, y_train)\n",
    "X_test = lda.transform(X_test)\n",
    "explained_variance = lda.explained_variance_ratio_\n",
    "print(explained_variance)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n",
      "[[16  0  0]\n",
      " [ 0 21  0]\n",
      " [ 0  0  8]]\n"
     ]
    }
   ],
   "source": [
    "#Apply Logic Regresson after reducing the features\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn import metrics\n",
    "# import warnings filter\n",
    "from warnings import simplefilter\n",
    "# ignore all future warnings\n",
    "simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "lr_model =LogisticRegression(C=0.7, random_state=42)\n",
    "lr_model.fit(X_train, y_train.ravel())\n",
    "lr_predict_test = lr_model.predict(X_test)\n",
    "print(lr_model.score(X_train,y_train))\n",
    "\n",
    "# Making the Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test, lr_predict_test)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import ListedColormap\n",
    "#Define Variables\n",
    "clf = lr_model\n",
    "h = 0.1\n",
    "X_plot, z_plot = X_train, y_train \n",
    "\n",
    "#Template for all Regression\n",
    "x_min, x_max = X_plot[:, 0].min() - 1, X_plot[:, 0].max() + 1\n",
    "y_min, y_max = X_plot[:, 1].min() - 1, X_plot[:, 1].max() + 1\n",
    "xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                     np.arange(y_min, y_max, h))\n",
    "\n",
    "# Plot the decision boundary. For that, we will assign a color to each\n",
    "# point in the mesh\n",
    "Z = clf.predict(np.array([xx.ravel(), yy.ravel()]).T)\n",
    "Z = Z.reshape(xx.shape)\n",
    "plt.contourf(xx, yy, Z,\n",
    "             alpha = 0.7, cmap = ListedColormap(('blue', 'red', 'green')))\n",
    "\n",
    "\n",
    "for i, j in enumerate(np.unique(z_plot)):\n",
    "    plt.scatter(X_plot[z_plot == j, 0], X_plot[z_plot == j, 1],\n",
    "                c = ['blue', 'red', 'green'][i], cmap = ListedColormap(('blue', 'red', 'green')), label = j)\n",
    "   #X[:, 0], X[:, 1] \n",
    "plt.xlim(xx.min(), xx.max())\n",
    "plt.ylim(yy.min(), yy.max())\n",
    "plt.title('Logistic Regression After LDA')\n",
    "plt.xlabel('Independent Variable 1')\n",
    "plt.ylabel('Independent Variable 2')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using other dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.]\n"
     ]
    }
   ],
   "source": [
    "#Import Libraries\n",
    "import pandas as pd                 # pandas is a dataframe library\n",
    "import matplotlib.pyplot as plt      # matplotlib.pyplot plots data\n",
    "%matplotlib inline\n",
    "\n",
    "#Read the data\n",
    "df = pd.read_csv(\"Data/Classification/pima-data.csv\")\n",
    "\n",
    "#Check the Correlation\n",
    "df.corr()\n",
    "#Delete the correlated feature\n",
    "del df['skin']\n",
    "\n",
    "#Data Molding\n",
    "diabetes_map = {True : 1, False : 0}\n",
    "df['diabetes'] = df['diabetes'].map(diabetes_map)\n",
    "\n",
    "#Splitting the data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "#This will copy all columns from 0 to 7(8 - second place counts from 1)\n",
    "X = df.iloc[:, 0:8].values\n",
    "y = df.iloc[:, 8].values\n",
    "\n",
    "split_test_size = 0.30\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split_test_size, random_state=42) \n",
    "\n",
    "#Imputing\n",
    "from sklearn.impute import SimpleImputer \n",
    "\n",
    "#Impute with mean all 0 readings\n",
    "fill_0 = SimpleImputer(missing_values=0, strategy=\"mean\")\n",
    "\n",
    "X_train = fill_0.fit_transform(X_train)\n",
    "X_test = fill_0.fit_transform(X_test)\n",
    "\n",
    "# Perform Feature Scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "# Applying LDA\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "lda = LDA(n_components = 1)\n",
    "X_train = lda.fit_transform(X_train, y_train)\n",
    "X_test = lda.transform(X_test)\n",
    "explained_variance = lda.explained_variance_ratio_\n",
    "print(explained_variance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7803\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Calculate Accuracy on training data\n",
    "# predict values using the training data\n",
    "nb_predict_train = nb_model.predict(X_train)\n",
    "\n",
    "# import the performance metrics library\n",
    "from sklearn import metrics\n",
    "\n",
    "# Accuracy\n",
    "print(\"Accuracy: {0:.4f}\".format(metrics.accuracy_score(y_train, nb_predict_train)))\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Kernel PCA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import Libraries\n",
    "import pandas as pd                 # pandas is a dataframe library\n",
    "import matplotlib.pyplot as plt      # matplotlib.pyplot plots data\n",
    "%matplotlib inline\n",
    "\n",
    "#Read the data\n",
    "df = pd.read_csv(\"Data/Classification/pima-data.csv\")\n",
    "\n",
    "#Check the Correlation\n",
    "df.corr()\n",
    "#Delete the correlated feature\n",
    "del df['skin']\n",
    "\n",
    "#Data Molding\n",
    "diabetes_map = {True : 1, False : 0}\n",
    "df['diabetes'] = df['diabetes'].map(diabetes_map)\n",
    "\n",
    "#Splitting the data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "#This will copy all columns from 0 to 7(8 - second place counts from 1)\n",
    "X = df.iloc[:, 0:8]\n",
    "y = df.iloc[:, 8]\n",
    "\n",
    "split_test_size = 0.30\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=split_test_size, random_state=42) \n",
    "\n",
    "#Imputing\n",
    "from sklearn.impute import SimpleImputer \n",
    "\n",
    "#Impute with mean all 0 readings\n",
    "fill_0 = SimpleImputer(missing_values=0, strategy=\"mean\")\n",
    "\n",
    "X_train = fill_0.fit_transform(X_train)\n",
    "X_test = fill_0.fit_transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform Feature Scaling\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "sc_X = StandardScaler()\n",
    "X_train = sc_X.fit_transform(X_train)\n",
    "X_test = sc_X.transform(X_test)\n",
    "\n",
    "# Applying PCA\n",
    "from sklearn.decomposition import KernelPCA\n",
    "kpca = KernelPCA(n_components = 2, kernel = 'rbf')\n",
    "X_train = kpca.fit_transform(X_train)\n",
    "X_test = kpca.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.7207\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Training with Naive Bayes\n",
    "from sklearn.naive_bayes import GaussianNB\n",
    "\n",
    "# create Gaussian Naive Bayes model object and train it with the data\n",
    "nb_model = GaussianNB()\n",
    "\n",
    "nb_model.fit(X_train, y_train.ravel())\n",
    "# Calculate Accuracy on training data\n",
    "# predict values using the training data\n",
    "nb_predict_train = nb_model.predict(X_train)\n",
    "\n",
    "# import the performance metrics library\n",
    "from sklearn import metrics\n",
    "\n",
    "# Accuracy\n",
    "print(\"Accuracy: {0:.4f}\".format(metrics.accuracy_score(y_train, nb_predict_train)))\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}