Linear Discriminant Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('Desktop/CAT/Data Science with Python/Datasets/Wine.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dataset.iloc[:, :-1].values\n",
    "y = dataset.iloc[:, -1].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "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.2, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import StandardScaler\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
    "lda = LDA(n_components=2)\n",
    "X_train = lda.fit_transform(X_train, Y_train)   #Basic diff in PCA & LDA; passing both x & y here.\n",
    "X_test = lda.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(criterion='entropy', n_estimators=10, random_state=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "classifier = RandomForestClassifier(n_estimators=10, criterion='entropy', random_state=0)\n",
    "classifier.fit(X_train, Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [3 3]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [3 3]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [3 3]\n",
      " [3 3]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [3 3]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [2 2]\n",
      " [3 3]\n",
      " [1 1]\n",
      " [1 1]\n",
      " [2 2]\n",
      " [1 1]\n",
      " [1 1]\n",
      " [1 1]]\n"
     ]
    }
   ],
   "source": [
    "y_pred = classifier.predict(X_test)\n",
    "y_pred = y_pred.reshape(len(y_pred), 1)\n",
    "Y_test = Y_test.reshape(len(Y_test), 1)\n",
    "print(np.concatenate((y_pred, Y_test), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14  0  0]\n",
      " [ 0 16  0]\n",
      " [ 0  0  6]]\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, accuracy_score\n",
    "cm = confusion_matrix(Y_test, y_pred)\n",
    "print(cm)\n",
    "acc = accuracy_score(Y_test, y_pred)\n",
    "print(acc)"
   ]
  },
  {
   "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": [
    "from matplotlib.colors import ListedColormap\n",
    "x_set, y_set = X_train, Y_train\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",
    "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], c=ListedColormap(('red', 'green','blue'))(i), label=j)\n",
    "    \n",
    "plt.title('LDA Random Forest Classification (Training Set)')\n",
    "plt.xlabel('feature1')\n",
    "plt.ylabel('feature2')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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": 4
}