Kernel PCA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kernal PCA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing Libraries**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numpy allows us to work with array.\n",
    "import numpy as np\n",
    "\n",
    "# Maptplotlib which allows us to plot some chart.\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Pandas allows us to not only import the datasets but also create the matrix of features(independent) and \n",
    "# dependent variable.\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Importing the dataset**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The independent variable usally in the first columns of dataset and dependent variable usally in the last columns of the data sets.\n",
    "- X is Independent Variable.\n",
    "- Y is Dependent Variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.423e+01 1.710e+00 2.430e+00 ... 1.040e+00 3.920e+00 1.065e+03]\n",
      " [1.320e+01 1.780e+00 2.140e+00 ... 1.050e+00 3.400e+00 1.050e+03]\n",
      " [1.316e+01 2.360e+00 2.670e+00 ... 1.030e+00 3.170e+00 1.185e+03]\n",
      " ...\n",
      " [1.327e+01 4.280e+00 2.260e+00 ... 5.900e-01 1.560e+00 8.350e+02]\n",
      " [1.317e+01 2.590e+00 2.370e+00 ... 6.000e-01 1.620e+00 8.400e+02]\n",
      " [1.413e+01 4.100e+00 2.740e+00 ... 6.100e-01 1.600e+00 5.600e+02]]\n"
     ]
    }
   ],
   "source": [
    "dataset = pd.read_csv(\"Wine.csv\")\n",
    "x = dataset.iloc[:, :-1].values\n",
    "y = dataset.iloc[:, -1].values\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3\n",
      " 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3]\n"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Splitting the dataset into the training set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.364e+01 3.100e+00 2.560e+00 ... 9.600e-01 3.360e+00 8.450e+02]\n",
      " [1.260e+01 2.460e+00 2.200e+00 ... 7.300e-01 1.580e+00 6.950e+02]\n",
      " [1.196e+01 1.090e+00 2.300e+00 ... 9.900e-01 3.130e+00 8.860e+02]\n",
      " ...\n",
      " [1.242e+01 1.610e+00 2.190e+00 ... 1.060e+00 2.960e+00 3.450e+02]\n",
      " [1.390e+01 1.680e+00 2.120e+00 ... 9.100e-01 3.330e+00 9.850e+02]\n",
      " [1.416e+01 2.510e+00 2.480e+00 ... 6.200e-01 1.710e+00 6.600e+02]]\n"
     ]
    }
   ],
   "source": [
    "# Importing Package\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Dividing training and test set.\n",
    "# The best ratio is 80 - 20 for trainging and testing respectively.\n",
    "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.25, random_state = 0)\n",
    "\n",
    "print(x_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 2 3 1 3 3 1 3 1 2 3 3 2 3 3 1 2 3 2 2 3 2 1 2 2 2 1 1 2 2 3 3 2 2 2 3\n",
      " 3 1 3 2 2 2 2 2 1 1 2 1 3 1 3 1 1 2 1 2 2 1 3 2 1 2 2 2 3 1 3 3 1 1 2 3 1\n",
      " 1 2 2 1 1 1 3 2 1 2 3 1 2 3 3 1 1 3 1 3 2 1 1 2 1 3 2 3 1 3 3 3 1 2 2 2 2\n",
      " 3 3 2 2 1 2 3 3 1 1 3 2 2 2 1 1 1 2 2 2 1 3]\n"
     ]
    }
   ],
   "source": [
    "print(y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Feature Scaling**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Package\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "sc = StandardScaler()\n",
    "\n",
    "# Fitting and Transforming\n",
    "x_train = sc.fit_transform(x_train)\n",
    "x_test = sc.transform(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Applying Kernel PCA**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing Package\n",
    "from sklearn.decomposition import KernelPCA\n",
    "\n",
    "kpca = KernelPCA(n_components = 2, kernel = 'rbf')\n",
    "\n",
    "x_train = kpca.fit_transform(x_train)\n",
    "x_test = kpca.transform(x_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Training the Logistic Regression model on the Training Set**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LogisticRegression(random_state=0)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Importing Package\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "classifier = LogisticRegression(random_state = 0)\n",
    "\n",
    "# Fitting\n",
    "classifier.fit(x_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Making the Confusion Matrix**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[16  0  0]\n",
      " [ 0 21  0]\n",
      " [ 0  0  8]]\n",
      "Accuracy Score of PCA is 1.0\n"
     ]
    }
   ],
   "source": [
    "# Importing Package\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "\n",
    "# Predicting\n",
    "y_pred = classifier.predict(x_test)\n",
    "\n",
    "# Confusion Matrix\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "print(cm)\n",
    "\n",
    "# Accuracy Score\n",
    "print(\"Accuracy Score of PCA is\",accuracy_score(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Visualising the Training Set results**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing Package\n",
    "from matplotlib.colors import ListedColormap\n",
    "\n",
    "x_set, y_set = x_train, y_train\n",
    "\n",
    "x1, x2 = np.meshgrid(np.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01),\n",
    "                     np.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01))\n",
    "\n",
    "plt.contourf(x1, x2, classifier.predict(np.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape),\n",
    "             alpha = 0.75, cmap = ListedColormap(('red', 'green', 'blue')))\n",
    "\n",
    "plt.xlim(x1.min(), x1.max())\n",
    "plt.ylim(x2.min(), x2.max())\n",
    "\n",
    "for i, j in enumerate(np.unique(y_set)):\n",
    "    plt.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1],\n",
    "                c = ListedColormap(('red', 'green', 'blue'))(i), label = j)\n",
    "plt.title('Logistic Regression (Training set)')\n",
    "plt.xlabel('PC1')\n",
    "plt.ylabel('PC2')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Visualising the Test Set results**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n",
      "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*.  Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Importing Package\n",
    "from matplotlib.colors import ListedColormap\n",
    "\n",
    "x_set, y_set = x_test, y_test\n",
    "\n",
    "x1, x2 = np.meshgrid(np.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step = 0.01),\n",
    "                     np.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01))\n",
    "\n",
    "plt.contourf(x1, x2, classifier.predict(np.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape),\n",
    "             alpha = 0.75, cmap = ListedColormap(('red', 'green', 'blue')))\n",
    "\n",
    "plt.xlim(x1.min(), x1.max())\n",
    "plt.ylim(x2.min(), x2.max())\n",
    "\n",
    "for i, j in enumerate(np.unique(y_set)):\n",
    "    plt.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1],\n",
    "                c = ListedColormap(('red', 'green', 'blue'))(i), label = j)\n",
    "\n",
    "plt.title('Logistic Regression (Test set)')\n",
    "plt.xlabel('PC1')\n",
    "plt.ylabel('PC2')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}