assignment3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading the dataset\n",
    "from sklearn.datasets import load_breast_cancer\n",
    "df = load_breast_cancer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#get features (X) and class (y) from the dataset \n",
    "X = df.data\n",
    "y = df.target\n",
    "\n",
    "#intialize a dictionary to capture execution time and accuracy for various models\n",
    "models_info = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the dataset and split it into a training set (70%) and a test set (30%)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Splitting the data into Training Set and Test Set\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.3,random_state=0)\n",
    "\n",
    "#Normalizing the features\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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train <b>Logistic Regression</b> on the dataset and time how long it takes. Look up how to compute execution time of Python code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- execution time in 0.24829888343811035 seconds ---\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Fitting Logistic Regression to Training Set\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifierObj= LogisticRegression(random_state=0)\n",
    "classifierObj.fit(X_train, y_train)\n",
    "\n",
    "execTimeLR = time.time() - start_time\n",
    "print(\"--- execution time in %s seconds ---\" % execTimeLR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the resulting model on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Making predictions on the Test Set\n",
    "y_pred= classifierObj.predict(X_test)\n",
    "\n",
    "#Evaluating the predictions using a Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "lrScore = classifierObj.score(X_test,y_test)\n",
    "\n",
    "models_info[\"Logistic Regression\"] = lrScore *100, execTimeLR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, use <b>PCA</b> to reduce the dataset’s dimensionality, with an explained variance ratio of at least 95%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Applying PCA\n",
    "from sklearn.decomposition import PCA\n",
    "pcaObj= PCA(n_components=None)\n",
    "X_train_pca = pcaObj.fit_transform(X_train)\n",
    "X_test_pca = pcaObj.transform(X_test)\n",
    "components_variance= pcaObj.explained_variance_ratio_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XmcXHWZ7/HPt/cknQXSWSAQkkBYggLByCJRGQSGcQEVxwGXETd0LuBFR2d0FmSYuTNeda7iMqOAKCKKuIBhRFlc2JGEHQJZupNAFjrdCVm6k96f+8c53RRNLydLpbq6vu/Xq191zqlTp56T6tTT5/c7v+eniMDMzAygrNABmJnZyOGkYGZmfZwUzMysj5OCmZn1cVIwM7M+TgpmZtbHScHMzPo4KZiZWR8nBTMz61NR6AB2VV1dXcyaNavQYZiZFZVHHnmkOSKmDLdf0SWFWbNmsWTJkkKHYWZWVCStybKfm4/MzKyPk4KZmfVxUjAzsz5OCmZm1sdJwczM+uQtKUi6VtJGSU8P8rwkfUPSSklPSjo+X7GYmVk2+bxS+AFw1hDP/wUwN/25EPjvPMZiZmYZ5G2cQkTcI2nWELucA/wwkvlAH5I0SdIBEbEhXzGZWXHo6Qk6e3ro6g66ul9e7uzuoasn6O7poTN9rqsn2dbZ3UN3T/Tt1xNBdw/0RNATQUTvcnL8vuUIIme5JyD6759OW9zTkzzmTmKcO6NxpM8MNMvxoBMf78KUyG85ahrHHjwp8/67o5CD12YAL+Ssr023vSopSLqQ5GqCmTNn7pPgzEpJRNDe1UNbZ3ffY1tnD+1dyWPu9vauZHtHVw8dXT20p48d3T20d3Ynj+n2zq4eOruT5zq7go7uZN+Xt/XQkX6Jd3b39H3J95TY1PFStv2mTqgZ1UlhoH+GAX8VIuIq4CqABQsWlNivi1kiItjZ2U1LWxct7V20tnenj120diTrre1dOdu62dHR1fcF39bZTVtXD20d3bR1db9ie3tXzx7FViaoriinqqIs+Skvo7p3uaKMyvIyKsvFhKpKqsqVsy19vkxUlJdRUS4qy9LH8jIq0u2V5aKib3u6nPOairJkW2W5KC9LXlumZLlMUFYmypQuS0ikzwnxyueFUBmv2D85x+R1vV9cyvkmz/0y692srN/0I0whk8Ja4OCc9YOA9QWKxSzv2jq72bazk21tnWzd2cm2nV3JY1snW3d0sr29i+1tXWxv66Slvavvyz93W9a/oMdUljOuuoKxVeWMqSynprKM6spyJo6pZNr4amoqX95eU1lOde9yRTnV6WNN7+sqXt6vd72qIudLv7yMinLfyDhaFDIpLAIulnQjcCKw1f0JVix6eoItOzvZ3NpOc0sHm1o6+pY3t3awqbWdTS0dbGrtYOvOJAl0DPPXeE1lGeNrKhlfXUFtTQXjayqYXDuW2upKxtdUUFudbBuXPo6tqmBcdTm11clybXWyPraqgvKy4vwr1Qovb0lB0k+AU4E6SWuBLwKVABHxHeA24K3ASmAH8OF8xWK2K3Z2dPPitjY2bN1J47Y2Xtzazotbd/LitjZe3NrGi9vaaG7poHuQP9v3G1vJ/uOqmFxbzdyptUwaW8mEMZVMqKlk4phkeeKYSibUVPStT6ippKrCf21b4eXz7qPzh3k+gIvy9f5mQ+npCdZt2cmyF7ezrHE7yxu3s7yxhXUv7WBbW9er9h9fU8H0CTVMn1jD4dPGM21CDZNrky/+yeOqkuVx1ew3ttJNKVbUiq50ttmu2ri9jeUvtiRf/i9u57nG7axo3M6Oju6+fWZMGsPcabUsOGQ/pk+sYfqEGg6YWMO0dHlctf+rWGnwb7qNOhu27uTB+k08WL+JB+o3sW7Lzr7n6mqrOHzaeN674GCOmD6ew6eNZ+60WibUVBYwYrORw0nBil5zS3uSBBqSRLCquRWASWMrOXnOZD66cDZHHpAkgLra6gJHazayOSlY0dnR0cX9Kzdx/8pmHqzfxLLG7QDUVldw4uz9ef+JMzn50MkcNX0CZb4Lx2yXOClYUdi4vY3fP7uRO5c2ct/KZtq7eqipLOP1s/bnnPkH8oZD63jNgRPcyWu2h5wUbESKCFZsbOHOpY3c9Wwjj7+whYikQ/j8E2ZyxrxpLJi1H9UV5YUO1WxUcVKwEaO7J1i8enNfIlizaQcAxxw0kc+cfjinz5vGkdPHF235ALNi4KRgBRURPP7CFn71+Hr+58kNNLe0U1VexhsOm8zH3ziH04+axvSJNYUO06xkOClYQaxo3M6vHl/PoifW8/zmHVRVlHHaEVN5x7EH8uYjplDrcQFmBeH/ebbPrNuyk1ufWM+vHl/Psxu2USY45bA6LjntMP78NdM9VsBsBHBSsLzasqODW5/cwKLH17F49UsAzJ85icvfMY+3HXMgU8Z73IDZSOKkYHtdR1cPdy9v4hePrOX3z22ko7uHuVNr+dyfH8E7jjmQmZPHFjpEMxuEk4LtFRHB0+u28YtH17LoifVsbu2grraKD5x0COe+bgbzDpjgu4bMioCTgu2RF7e2cfNj6/jlo2tZsbGFqooyzpg3jXOPn8Eb506h0oPJzIqKk4Ltsp6e4I6ljdzwpzXct7KZCFhwyH78+7tey9teewATx7rD2KxYOSlYZm2d3dz82DquvqeBhuZWZkwawyWnzeXd82cwq25cocMzs73AScGGtXVHJz/60xq+f/9qmlvaee2MiXzrffM56+jprjVkNspkSgqSFgJzI+L7kqYAtRGxKr+hWaGt27KT7927ihsXP8+Ojm7efPgUPvHmOZw8Z7I7jc1GqWGTgqQvAguAI4Dvk8yz/CPglPyGZoXy7IZtXHVPA4ueWI+As489kI+/aQ5HHTCh0KGZWZ5luVJ4FzAfeBQgItZLGp/XqKwgHlmzmW/8biV3L29iXFU5F7xhFh9ZOJsZk8YUOjQz20eyJIWOiAhJASDJPYqjzJLVm7nydyu4d0Uzk8dV8bk/P4IPnHiI7yIyK0FZksJNkr4LTJL0ceAjwNX5Dcv2hcWrN3PlXSu4b2UzdbVV/MNbj+QDJx3C2Crff2BWqob93x8RX5V0BrCNpF/hsoi4M++RWd48vGozV/5uOfev3ERdbRX/+NajeP9JM50MzCxTR/Ns4N7eRCBpjKRZEbE638HZ3vXwqs18/a7lPFC/ibraav7pbUfx/hMPYUyVZy8zs0SWPw1/BrwhZ7073fb6vERke93S9dv4t18vdTIws2FlSQoVEdHRuxIRHZKq8hiT7SURwQ8eWM1/3PYcE8ZU8M9vn8f7TpjpZGBmg8qSFJoknR0RiwAknQM0Zzm4pLOAK4Fy4JqI+FK/5w8BrgWmAJuBD0TE2l2I3waxubWDv/v5E9z17EbecuRUvvKXx7L/OOdyMxtalqTwSeAGSd8CBLwA/PVwL5JUDnwbOANYCyyWtCgilubs9lXghxFxnaTTgP8APriL52D9PFi/iUt/+hgvtXZy2dvn8eFTZnkEspllkuXuo3rgJEm1gCJie8ZjnwCsjIgGAEk3AucAuUlhHvDpdPkPwC1ZA7dX6+ru4Ru/W8E3/7CS2ZPH8b0PvZ7XzJhY6LDMrIhkufuoGjgXmAVU9P7FGRFXDPPSGSRXFb3WAif22+eJ9NhXkoycHi9pckRs6hfDhcCFADNnzhwu5JK0bstOLr3xMRavfon3vO4g/uXsoxlX7VtMzWzXZPnW+BWwFXgEaN+FYw/UXhH91j8LfEvSBcA9wDqg61UvirgKuApgwYIF/Y9R8n779Iv8/S+epLsn+PpfHcc7588odEhmVqSyJIWDIuKs3Tj2WuDg3OMA63N3iIj1wLsB0uapcyNi6268V0lq6+zm3369lB899DzHHDSRb54/n0MmuwqJme2+LEnhAUmvjYindvHYi4G56eC3dcB5wPtyd5BUB2yOiB7gCyR3IlkGre1dvPe7D/LM+m1c+KY5fPbMI6iq8NwGZrZnsiSFhcAFklaRNB8JiIg4ZqgXRUSXpIuB20luSb02Ip6RdAWwJL3F9VTgP9Jie/cAF+3+qZSWf/7V00mJ6w++jjOPnl7ocMxslMiSFP5idw8eEbcBt/XbdlnO8s+Bn+/u8UvVz5a8wC8fXcelp891QjCzvSrLLalrACRNBWryHpENaUXjdi771TOcPGcyl5w2t9DhmNkoM2wjtKSzJa0AVgF3A6uB3+Q5LhvAzo5uLvrxo4yrLufK846jvMwD0sxs78rSM/mvwEnA8oiYDbwFuD+vUdmAvrjoaVZsbOFrf3UcUyf4os3M9r4sSaEzHUxWJqksIv4AHJfnuKyfmx9by01L1nLRqYfxxrlTCh2OmY1SWTqat6RjCO4hqYG0kQEGmFn+1De18I83P80Js/bn0tPdj2Bm+ZPlSuEcYCdJjaLfAvXAO/IZlL2srbObi254lOqKMq48/zgqyj0WwczyJ8vdR605q9flMRYbwBX/s5TnXtzO9z/8eg6YOKbQ4ZjZKDdoUpB0X0QslLSdV9Ys6h28NiHv0ZW4W59Yz4//9DyfePMc/uyIqYUOx8xKwKBJISIWpo/j91041mt1cytf+OVTHD9zEp8984hCh2NmJWLIBmpJZZKe3lfBWKK9q5uLf/Io5WXim+87nkr3I5jZPjLkt01aqO4JSZ7EYB/6918/y9PrtvHVvzyWGZPcj2Bm+06WW1IPAJ6R9DDQ1+kcEWfnLaoSdtfSRq57cA0fXTibM+ZNK3Q4ZlZisiSFf8l7FAZAZ3cP//brpRw+rZa/P+vIQodjZiUoyy2pd++LQAx+8vDzrN60g2svWOC5EcysILIUxDtJ0mJJLZI6JHVL2rYvgislLe1dXHnXCk6cvb9vPzWzgsnSfPQtklnTfgYsAP4acK2FveyqexrY1NrB9956FJKrn5pZYWRJCkTESknlEdENfF/SA3mOq6Rs3NbGNfc28LZjDuC4gycVOhwzK2FZksIOSVXA45K+DGwAPDv8XvT1362go6uHz3mQmpkVWJbezA+m+11MckvqwcC5+QyqlNQ3tfDTxS/w/hNnMqvOudbMCivLlcLxwG0RsQ3fnrrXffm3z1FTUcYlb3E3jZkVXpYrhbOB5ZKul/Q2SZn6IWx4j6zZzO3PNPKJNx9KXW11ocMxMxs+KUTEh4HDSO4+eh9QL+mafAc22kUE/3Hbc0wZX83H3ji70OGYmQHZrhSIiE7gN8CNwCMkE+/YHrhjaSNL1rzEp08/nLFVvvgys5Ehy+C1syT9AFgJvAe4hqQeku2mru4evvzb5zh0yjjeu+CgQodjZtYny5+oF5BcIXwiItrzG05puGnJWuqbWvnuB1/n6TXNbETJUvvovH0RSKnY0dHF1+5azusO2Y8zXQXVzEaYvP6ZmjY9LZO0UtLnB3h+pqQ/SHpM0pOS3prPeEaCa+5dRdP2dv7hrUe6nIWZjTh5SwqSyoFvA38BzAPOlzSv327/BNwUEfNJ6iv9V77iGQmaW9r57t31nDlvGq87ZP9Ch2Nm9ir5vFI4AVgZEQ0R0UHSL9H/rqUAJqTLE4H1eYyn4L75uxW0dfXwd54rwcxGqEH7FCQ9RfKlPaCIOGaYY88AXshZXwuc2G+fy4E7JF1CUk/p9EFiuRC4EGDmzOKcGXR1cys3/Ol5/ur1B3PY1NpCh2NmNqChOprfnj5elD5enz6+H9iR4dgDNZj3TzLnAz+IiP+UdDJwvaTXpHNDv/yiiKuAqwAWLFgwaKIayb5y+zIqy8u41OUszGwEGzQpRMQaAEmnRMQpOU99XtL9wBXDHHstSfG8Xgfx6uahjwJnpe/3oKQaoA7YmC384rByYwu/fmoDF//ZYUydUFPocMzMBpWlT2GcpIW9K5LeQLbS2YuBuZJmp6W3zwMW9dvneeAt6XGPAmqApiyBF5Nr719FVUUZF5wyq9ChmJkNKcvgtY8C10qaSNL8sxX4yHAvioguSRcDtwPlwLUR8YykK4AlEbEI+FvgakmfTo99QUQUZfPQYDa3dvCLR9by7vkzXPTOzEa8LIPXHgGOlTQBUERszXrwiLgNuK3ftstylpcCp/R/3Whyw0NraO/q4SMLXfTOzEa+LLWPpkn6HvDTiNgqaZ6kj+6D2Ipee1c31z24hjcfPoXDp40vdDhmZsPK0qfwA5ImoAPT9eXApfkKaDRZ9Ph6mlvaXRrbzIpGlqRQFxE3AT2Q9BUA3XmNahSICL533yqOmDaehYfVFTocM7NMsiSFVkmTSccYSDqJpLPZhnD/yk089+J2PvrG2a5xZGZFI8vdR58huZX00HR8whSSeRVsCNfc10BdbTXnHHfg8DubmY0QWe4+elTSm4EjSEYpL0tnYrNBrGjczh+XNfGZMw6nuqK80OGYmWWWdR7IE4BZ6f7HSyIifpi3qIrctfevorqijPefWJx1msysdA2bFCRdDxwKPM7LHcwBOCkMYFNLO794dB3nHj+DyR6sZmZFJsuVwgJg3mgbaZwvP3roeTq6evjIKb4N1cyKT5a7j54Gpuc7kNGgrbOb6x9azalHTGGuB6uZWRHKcqVQByyV9DDQ3rsxIs7OW1RFatET62lu6eBjC+cUOhQzs92SJSlcnu8gRoOI4Hv3ruLI6eM55bDJhQ7HzGy3ZLkl9e59EUixu29lM8sat/OV9xzjwWpmVrSGmo7zvohYKGk7r5wxTUBExIRBXlqSrrl3FXW11ZztwWpmVsSGmnltYfroHtNhLG/czt3Lm/hbD1YzsyKXdfAakqaSzIwGQEQ8n5eIitC196WD1U46pNChmJntkSzzKZwtaQWwCrgbWA38Js9xFY3mlnZ++dg6zn3dQew/rqrQ4ZiZ7ZEs4xT+FTgJWB4Rs0nmVL4/r1EVkR89tMaD1cxs1MiSFDojYhNQJqksIv4AHJfnuIpCW2c31z+4htOOnMphU2sLHY6Z2R7L0qewRVItcA9wg6SNQFd+wyoOtz6xnk2tHXzM8y+b2SiR5UrhHGAn8Gngt0A98I58BlUsbntqAwfvP4aTD/VgNTMbHbIMXmvNWb0uj7EUlZb2Lu6v38QHTjzEg9XMbNQYavDagIPW8OA1AO5Z3kRHVw9nHj2t0KGYme01Qw1e86C1Idy5tJFJYytZcMh+hQ7FzGyvyTR4TdLxwEKSK4X7IuKxvEY1wnV29/D75zbylqOmUlGepVvGzKw4ZBm8dhlJX8JkkjLaP5D0T/kObCRbvHozW3d2cuY8Nx2Z2eiS5UrhfGB+RLQBSPoS8Cjwb8O9UNJZwJVAOXBNRHyp3/NfA/4sXR0LTI2ISdnDL4w7nmmkuqKMNx0+pdChmJntVVmSwmqSmkdt6Xo1yW2pQ5JUDnwbOANYCyyWtCgilvbuExGfztn/EmB+5sgLJCK4c2kjCw+rY2xV5tJRZmZFIUuDeDvwjKQfSPo+yfScLZK+IekbQ7zuBGBlRDRERAdwI8mYh8GcD/wka+CF8uyG7azbspMz3HRkZqNQlj91b05/ev0x47FnAC/krK8FThxoR0mHALOB32c8dsHcubQRCd5ylJOCmY0+WZLCbyJiY+4GSUdExLJhXjfQiK4YYBvAecDPI6J7wANJFwIXAsycOXOYt82vO5a+yPyDJzFlfHVB4zAzy4cszUf3Snpv74qkv+WVVw6DWQscnLN+ELB+kH3PY4imo4i4KiIWRMSCKVMK17m7bstOnlm/jTOPnl6wGMzM8ilLUjgV+KCkn0m6BzicpL9gOIuBuZJmS6oi+eJf1H8nSUcA+wEPZo66QO5a2gjg/gQzG7WGTQoRsYGkEN7JwCzghxHRkuF1XcDFwO3As8BNEfGMpCsknZ2z6/nAjRExWNPSiHHn0kbmTBnHoVNcJtvMRqdh+xQk3QlsAF5D0gR0raR7IuKzw702Im4Dbuu37bJ+65fvSsCFsnVnJw81bOKjb3SZbDMbvbI0H307Iv46IrZExNPAG4CteY5rxPnjso109QRnznN/gpmNXlmaj26RdIik09NNlcDX8xvWyHPH0kbqaquZf/CIH3BtZrbbstQ++jjwc+C76aaDgFvyGdRI097Vzd3Lmjj9qKmUlXnuBDMbvbI0H10EnAJsA4iIFcDUfAY10jzUsJmW9i7fdWRmo16mMhdpmQoAJFUw+CC0UemOZ15kbFU5pxxWV+hQzMzyKktSuFvSPwBjJJ0B/Ay4Nb9hjRw9PcFdzzbyprlTqKksL3Q4ZmZ5lSUpfB5oAp4CPkFyi2nJzKfw1LqtNG5rd9ORmZWEYccpREQPcHX6U3LuXNpIeZk47ciS6kYxsxLluSSHcefSRl4/az/2G1dV6FDMzPLOSWEIaza1sqxxO2d4wJqZlYjMSUHSuHwGMhLdmRbA81zMZlYqsgxee4OkpSRF7ZB0rKT/yntkI8AdSxs5cvp4Dt5/bKFDMTPbJ7JcKXwN+HNgE0BEPAG8KZ9BjQSbWztYsnqzrxLMrKRkaj6KiBf6bRpwhrTR5HfPNtITuD/BzEpKluk4X5D0BiDSyXI+RdqUNJrdubSRAybW8JoZEwodipnZPpPlSuGTJPWPZpBMsXlcuj5qtXV2c++KZk4/ahqSC+CZWenIcqWgiHh/3iMZQe5b0czOzm7OPNr9CWZWWrJcKTwg6Q5JH5VUEpMJ3LH0RcZXV3Di7MmFDsXMbJ/KMsnOXJJaR0cDj0r6H0kfyHtkBRIR/P65Jk49cipVFR7bZ2alJevdRw9HxGeAE4DNwHV5jaqANrV20NzSzvEzS+KiyMzsFbIMXpsg6UOSfgM8AGwgSQ6jUv3GFgDmTKktcCRmZvtelo7mJ0im37wiIh7MczwF19DcCsCcupKr6mFmlikpzImIkplprX5jC9UVZcyYNKbQoZiZ7XODJgVJX4+IS4FFkl6VFCLi7LxGViANza3MrhtHWZnHJ5hZ6RnqSuH69PGr+yKQkaKhqYWjZ0wsdBhmZgUxaEdzRDySLh4XEXfn/pCMah512ru6eX7zDg51f4KZlagst6R+aIBtF2Q5uKSzJC2TtFLS5wfZ572Slkp6RtKPsxw3X57ftIOegEOn+s4jMytNQ/UpnA+8D5gtaVHOU+NJy2gPRVI58G3gDJKaSYslLYqIpTn7zAW+AJwSES9JKuhEyPVN6e2odU4KZlaahupT6B2TUAf8Z8727cCTGY59ArAyIhoAJN0InAMszdnn48C3I+IlgIjYmD30va++KbkddfYUNx+ZWWkaNClExBpgDXDybh57BpA7D8Na4MR++xwOIOl+oBy4PCJ+u5vvt8fqm1qYPqGG2uosd+qamY0+WUY0nyRpsaQWSR2SuiVty3Dsge7p7H9rawUwFzgVOB+4ZqCie5IulLRE0pKmpqYMb717GppameOrBDMrYVk6mr9F8oW9AhgDfAz4ZobXrQUOzlk/CFg/wD6/iojOiFgFLCNJEq8QEVdFxIKIWDBlypQMb73rIoKGphYOdXkLMythWQvirQTKI6I7Ir4P/FmGly0G5kqanc7Ydh6wqN8+t/QeS1IdSXNSQ9bg96bmlg62tXX5SsHMSlqWxvMd6Zf645K+TNL5POw3Z0R0SboYuJ2kv+DaiHhG0hXAkohYlD53pqSlJPM+fy4ihr2zKR8amlwIz8wsS1L4IMmX+sXAp0mahM7NcvCIuA24rd+2y3KWA/hM+lNQvXceHeorBTMrYcMmhfQuJICdwL/kN5zCaWhqoaayjAMnuhCemZWuoQavPcWr7xbqExHH5CWiAqlvamF2Xa0L4ZlZSRvqSuHt+yyKEaChuZXXuBCemZW44QavlYT2rm5e2LyDc449sNChmJkV1LB9CpK283IzUhVQCbRGxIR8BrYvrXEhPDMzIFtH8/jcdUnvZJTN0dzgQnhmZkDGwWu5IuIW4LQ8xFIwvbejeuCamZW6LM1H785ZLQMWMMRdScWotxDeOBfCM7MSl+Vb8B05y13AapIS2KNGvQvhmZkB2foUPrwvAimU3kJ47zxuRqFDMTMruCzNR7OBS4BZuftHxNn5C2vfaW7pYLsL4ZmZAdmaj24BvgfcCvTkN5x9r3cKTpfMNjPLlhTaIuIbeY+kQBp855GZWZ8sSeFKSV8E7gDaezdGxKN5i2ofqnchPDOzPlmSwmtJymefxsvNR8EoGavQ4EJ4ZmZ9siSFdwFzIqIj38EUggvhmZm9LMuI5ieASfkOpBB6C+G5k9nMLJHlSmEa8JykxbyyT6Hob0ntK4TnTmYzMyBbUvhi3qMokPqNvh3VzCxXlhHNd++LQAqhoTm5HXV2na8UzMygxOdTqN/oQnhmZrlKej6F+uZWDp3qqwQzs14lO59CbyE8T6xjZvaykp1Poamlne1tXb7zyMwsR8nOp/ByzSNfKZiZ9SrZ+RR6q6O6EJ6Z2cuG7VOQdJ2kSTnr+0m6NsvBJZ0laZmklZI+P8DzF0hqkvR4+vOxXQt/9zU0tboQnplZP1maj46JiC29KxHxkqT5w71IUjnwbeAMYC2wWNKiiFjab9efRsTFuxL03lDvQnhmZq+S5e6jMkn79a5I2p9syeQEYGVENKTF9G5kBPVFNDS1upPZzKyfLEnhP4EHJP2rpCuAB4AvZ3jdDOCFnPW16bb+zpX0pKSfSzo4w3H3WFtnN2tf2uFOZjOzfoZNChHxQ+BcoBFoAt4dEddnOPZA7TL9b2W9FZgVEccAdwHXDXgg6UJJSyQtaWpqyvDWQ3MhPDOzgWWq75D2A/TvCxjOWiD3L/+DgPX9jrspZ/Vq4P8O8v5XAVcBLFiwYI/HSDR4XmYzswHt8ojmXbAYmCtptqQq4DxgUe4Okg7IWT0beDaP8fTpvR3VhfDMzF4pb5XgIqJL0sXA7UA5cG1EPJP2SyyJiEXApySdTTIobjNwQb7iydXQ1MoBE10Iz8ysv7x+K0bEbcBt/bZdlrP8BeAL+YxhIPXNrR60ZmY2gHw2H41IEUHDRhfCMzMbSMklhaaWdra3uxCemdlASi4p1G90ITwzs8GUXFJoaE5vR53qpGBm1l/JJYX6jUkhvAMm1BQ6FDOzEafkkkJDc9LJ7EJ4ZmavVnpJocm3o5qZDaakkkJbZzcvuBCemdmgSioprNm0g3AhPDOzQZVUUqh3ITxZCc2SAAAI10lEQVQzsyGVVFJocCE8M7MhlVRSqHchPDOzIZVUUmhoavGdR2ZmQyiZpBAR6bzM7k8wMxtMySSFpu1JIbw57k8wMxtUySSF+qakEJ5rHpmZDa6EkkJy55EHrpmZDa5kksLU8dWcMW+aC+GZmQ2hZO7NPPPo6Zx59PRCh2FmNqKVzJWCmZkNz0nBzMz6OCmYmVkfJwUzM+vjpGBmZn2cFMzMrI+TgpmZ9XFSMDOzPoqIQsewSyQ1AWt28+V1QPNeDGckGG3nNNrOB0bfOY2284HRd04Dnc8hETFluBcWXVLYE5KWRMSCQsexN422cxpt5wOj75xG2/nA6DunPTkfNx+ZmVkfJwUzM+tTaknhqkIHkAej7ZxG2/nA6Dun0XY+MPrOabfPp6T6FMzMbGildqVgZmZDKJmkIOksScskrZT0+ULHs6ckrZb0lKTHJS0pdDy7Q9K1kjZKejpn2/6S7pS0In3cr5Ax7opBzudySevSz+lxSW8tZIy7StLBkv4g6VlJz0j63+n2ovychjifov2cJNVIeljSE+k5/Uu6fbakP6Wf0U8lVWU6Xik0H0kqB5YDZwBrgcXA+RGxtKCB7QFJq4EFEVG091ZLehPQAvwwIl6TbvsysDkivpQm7/0i4u8LGWdWg5zP5UBLRHy1kLHtLkkHAAdExKOSxgOPAO8ELqAIP6chzue9FOnnJEnAuIhokVQJ3Af8b+AzwC8j4kZJ3wGeiIj/Hu54pXKlcAKwMiIaIqIDuBE4p8AxlbyIuAfY3G/zOcB16fJ1JP9hi8Ig51PUImJDRDyaLm8HngVmUKSf0xDnU7Qi0ZKuVqY/AZwG/DzdnvkzKpWkMAN4IWd9LUX+i0Dyod8h6RFJFxY6mL1oWkRsgOQ/MDC1wPHsDRdLejJtXiqKZpaBSJoFzAf+xCj4nPqdDxTx5ySpXNLjwEbgTqAe2BIRXekumb/zSiUpaIBtxd5udkpEHA/8BXBR2nRhI89/A4cCxwEbgP8sbDi7R1It8Avg0ojYVuh49tQA51PUn1NEdEfEccBBJC0jRw20W5ZjlUpSWAscnLN+ELC+QLHsFRGxPn3cCNxM8oswGjSm7b697b8bCxzPHomIxvQ/bA9wNUX4OaXt1L8AboiIX6abi/ZzGuh8RsPnBBARW4A/AicBkyRVpE9l/s4rlaSwGJib9sZXAecBiwoc026TNC7tJEPSOOBM4OmhX1U0FgEfSpc/BPyqgLHssd4vztS7KLLPKe3E/B7wbET8v5ynivJzGux8ivlzkjRF0qR0eQxwOklfyR+A96S7Zf6MSuLuI4D0FrOvA+XAtRHxfwoc0m6TNIfk6gCgAvhxMZ6PpJ8Ap5JUdGwEvgjcAtwEzASeB/4yIoqi83aQ8zmVpEkigNXAJ3rb4ouBpIXAvcBTQE+6+R9I2uGL7nMa4nzOp0g/J0nHkHQkl5P8oX9TRFyRfk/cCOwPPAZ8ICLahz1eqSQFMzMbXqk0H5mZWQZOCmZm1sdJwczM+jgpmJlZHycFMzPr46RgRU3SHyXlfW5dSZ9KK2vekO/3KiRJkyT9r0LHYYXjpGAlK2e0Zxb/C3hrRLw/X/GMEJNIztVKlJOC5Z2kWelf2Ven9d7vSEdevuIvfUl1aUlwJF0g6RZJt0paJeliSZ+R9JikhyTtn/MWH5D0gKSnJZ2Qvn5cWthscfqac3KO+zNJtwJ3DBDrZ9LjPC3p0nTbd4A5wCJJn+63f7mkryqZ2+JJSZek29+Svu9TaRzV6fbVkv5d0oOSlkg6XtLtkuolfTLd51RJ90i6WdJSSd+RVJY+d356zKcl/d+cOFok/R8lNfUfkjQt3T5F0i/Sf4fFkk5Jt1+exvVHSQ2SPpUe6kvAoUrmFPiKpAPSWB5P3/ONu/2LYMUhIvzjn7z+ALOALuC4dP0mktGVkNRpWZAu1wGr0+ULgJXAeGAKsBX4ZPrc10gKmfW+/up0+U3A0+nyv+e8xySS+TTGpcddC+w/QJyvIxnpOg6oBZ4B5qfPrQbqBnjN35DU0alI1/cHakiq8h6ebvthTryrgb/JOY8nc85xY7r9VKCNJBGVk1S9fA9wIMno4SkkI9l/D7wzfU0A70iXvwz8U7r8Y2BhujyTpLwDwOXAA0B1+u++iaTk8qzef8N0v78F/jFdLgfGF/r3yT/5/dmVy2ezPbEqIh5Plx8h+fIZzh8iqXm/XdJW4NZ0+1PAMTn7/QSS+QwkTUjrwJwJnC3ps+k+NSRfigB3xsAlGRYCN0dEK4CkXwJvJCkRMJjTge9EWqI4IjZLOjY93+XpPtcBF5GUWYGX6249BdTmnGNbbw0b4OGIaEjj+EkaWyfwx4hoSrffQJIIbwE6gP9JX/sIyYRSvfHNS0r+ADCht24W8OtIyh60S9oITBvg/BYD1yopIndLzmdoo5STgu0ruTVXuoEx6XIXLzdj1gzxmp6c9R5e+bvbv1ZLkJRLPzciluU+IelEoHWQGAcqsT4cDfD+wx0n9zz6n2PveQ12ToPpjIje13TnHKcMODkidr4iwCRJ9P9MXvV9kCbaNwFvA66X9JWI+OEQcViRc5+CFdpqkmYbeLmi4676K+grdrY1IrYCtwOXpFUxkTQ/w3HuAd4paayS6rPvIimeNpQ7gE/2dlqnfR3PAbMkHZbu80Hg7l08pxOUVPUtIzm/+0iK0L057XspJyniNtxx7wAu7l2RdNww+28nac7q3f8Qkmatq0mqix6/i+dhRcZXClZoXwVukvRBkjby3fGSpAeACcBH0m3/StJc82SaGFYDbx/qIJHM2/sD4OF00zURMVTTEcA1wOHp+3SS9G98S9KHgZ+lyWIx8J1dPKcHSTp9X0uSrG6OiB5JXyApiSzgtogYrhzyp4BvS3qS5P/7PcAnB9s5IjZJul/S08BvSEpIfy49txbgr3fxPKzIuEqq2Qgj6VTgsxExZBIzywc3H5mZWR9fKZiZWR9fKZiZWR8nBTMz6+OkYGZmfZwUzMysj5OCmZn1cVIwM7M+/x98/I21WZmOHgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.cumsum(pcaObj.explained_variance_ratio_))\n",
    "plt.xlabel('number of components')\n",
    "plt.ylabel('cumulative explained variance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Principal Component  %Variance        %Cummulative    \n",
      "1                    43.69            43.69           \n",
      "2                    19.42            63.10           \n",
      "3                    9.66             72.77           \n",
      "4                    6.72             79.48           \n",
      "5                    5.50             84.98           \n",
      "6                    4.01             88.99           \n",
      "7                    2.18             91.18           \n",
      "8                    1.49             92.67           \n",
      "9                    1.37             94.04           \n",
      "10                   1.10             95.14           \n"
     ]
    }
   ],
   "source": [
    "cumsum = 0\n",
    "print('{:<20} {:<16} {:<16}'.format(\"Principal Component\", \"%Variance\", \"%Cummulative\"))\n",
    "for i in range(0,30):\n",
    "    cumsum = cumsum + components_variance[i]\n",
    "    print('{:<20} {:<16.2f} {:<16.2f}'.format(i+1, components_variance[i]*100, cumsum*100))\n",
    "    if (cumsum > 0.95):\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Applying PCA\n",
    "from sklearn.decomposition import PCA\n",
    "pcaObj= PCA(n_components = i+1 )\n",
    "X_train_pca = pcaObj.fit_transform(X_train)\n",
    "X_test_pca = pcaObj.transform(X_test)\n",
    "components_variance= pcaObj.explained_variance_ratio_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train a new Logistic Regression classifier on the PCA reduced dataset and see how long it takes. Was training much faster?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- execution time in 0.0021820068359375 seconds ---\n",
      "--- execution time difference in 0.24611687660217285 seconds ---\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Fitting Logistic Regression to Training Set\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifierObj= LogisticRegression(random_state=0)\n",
    "classifierObj.fit(X_train_pca, y_train)\n",
    "\n",
    "execTimePCA = time.time() - start_time\n",
    "print(\"--- execution time in %s seconds ---\" % execTimePCA)\n",
    "print(\"--- execution time difference in %s seconds ---\" % (execTimeLR - execTimePCA))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next evaluate the classifier on the test set: how does it compare to the previous classifier?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Making predictions on the Test Set\n",
    "y_pred_pca= classifierObj.predict(X_test_pca)\n",
    "\n",
    "#Evaluating the predictions using a Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm_pca = confusion_matrix(y_test, y_pred_pca)\n",
    "\n",
    "pcaScore = classifierObj.score(X_test_pca,y_test)\n",
    "\n",
    "models_info[\"PCA\"] = pcaScore * 100, execTimePCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use <b>LDA</b> to reduce the dataset’s dimensionality down to 1 linear discriminant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Applying LDA\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "ldaObj = LDA(n_components=1)\n",
    "X_train_lda = ldaObj.fit_transform(X_train,y_train)\n",
    "X_test_lda = ldaObj.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train a new Logistic Regression classifier on the LDA reduced dataset and see how long it takes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- execution time in 0.0008959770202636719 seconds ---\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Fitting Logistic Regression to Training Set\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifierObj= LogisticRegression(random_state=0)\n",
    "classifierObj.fit(X_train_lda, y_train)\n",
    "\n",
    "execTimeLDA = time.time() - start_time\n",
    "print(\"--- execution time in %s seconds ---\" % execTimeLDA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the classifier on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Making predictions on the Test Set\n",
    "y_pred_lda = classifierObj.predict(X_test_lda)\n",
    "\n",
    "#Evaluating the predictions using a Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm_lda = confusion_matrix(y_test, y_pred_lda)\n",
    "\n",
    "ldaScore = classifierObj.score(X_test_lda,y_test)\n",
    "\n",
    "models_info[\"LDA\"] = ldaScore * 100, execTimeLDA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use <b>Kernel PCA</b> to reduce the dataset’s dimensionality down to 2 features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#kernel PCA\n",
    "from sklearn.decomposition import KernelPCA\n",
    "kernelPCAObj = KernelPCA(n_components=2, kernel='rbf')\n",
    "X_train_kpca = kernelPCAObj.fit_transform(X_train)\n",
    "X_test_kpca = kernelPCAObj.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train a new Logistic Regression classifier on the Kernel PCA reduced dataset and see how long it takes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- execution time in 0.0010459423065185547 seconds ---\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Fitting Logistic Regression to Training Set\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifierObj = LogisticRegression(random_state=0)\n",
    "classifierObj.fit(X_train_kpca, y_train)\n",
    "\n",
    "execTimeKPCA = time.time() - start_time\n",
    "print(\"--- execution time in %s seconds ---\" % execTimeKPCA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the classifier on the test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Making predictions on the Test Set\n",
    "y_pred_kpca = classifierObj.predict(X_test_kpca)\n",
    "\n",
    "#Evaluating the predictions using a Confusion Matrix\n",
    "from sklearn.metrics import confusion_matrix\n",
    "cm_kpca = confusion_matrix(y_test, y_pred_kpca)\n",
    "\n",
    "kpcaScore = classifierObj.score(X_test_kpca, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "models_info[\"KPCA\"] = kpcaScore * 100, execTimeKPCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Models performance summary</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model                Accuracy     Execution Time\n",
      "Logistic Regression  97.6608      0.2483      \n",
      "PCA                  95.9064      0.0022      \n",
      "LDA                  96.4912      0.0009      \n",
      "KPCA                 90.0585      0.0010      \n"
     ]
    }
   ],
   "source": [
    "print('{:<20} {:<12} {:<12}'.format(\"Model\", \"Accuracy\", \"Execution Time\"))\n",
    "for model, info in models_info.items():\n",
    "    print('{:<20} {:<12.4f} {:<12.4f}'.format(model, info[0], info[1]))"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}