LDA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>LDA(Linear Discriminant Analysis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src='./lda_1.png' width='700' height='600'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### When PCA fails ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mean = [[2,2],[4,2]]\n",
    "C = [[0.01,0],[0,10]]\n",
    "X1 = np.random.multivariate_normal(mean[0],C,size=50)\n",
    "X2 = np.random.multivariate_normal(mean[1],C,size=50)\n",
    "X = np.concatenate((X1,X2))\n",
    "y = np.concatenate((np.zeros(50),np.ones(50)))\n",
    "plt.scatter(X1[:,0],X1[:,1])\n",
    "plt.scatter(X2[:,0],X2[:,1])\n",
    "plt.plot(3*np.ones(24),range(-12,12))\n",
    "plt.xlim([1,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "pca = PCA(1).fit(X)\n",
    "X_transform = pca.transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7ff42bda32b0>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD8CAYAAABjAo9vAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAHRJJREFUeJzt3XmUXGd55/HvU9VbdasXLW2p3VqttiXZsicSbePgwUEysY2Dl4FMjjlmYICDDiHxQCY4weNzQmb+yIKGIXOYCYwIMMOEiU2MMZDjYBuMPRocZCTLi6zFlmTZUqsltyz1ol5reeaPe6V0i24tt0p9u+r+PufUqaq3br33p9vVj95+b917zd0REZHKkYo7gIiIlJYKu4hIhVFhFxGpMCrsIiIVRoVdRKTCqLCLiFQYFXYRkQqjwi4iUmFU2EVEKkxVHCudN2+eL126NI5Vi4iUrW3bth1z99ZzLRdLYV+6dClbt26NY9UiImXLzN44n+U0FSMiUmFU2EVEKowKu4hIhVFhFxGpMCrsIiIVJpZvxYjMNI9u72Lj43s43DvMpS0Z7rtlBXetaY87lkgkKuySeI9u7+L+R15mOJsHoKt3mPsfeRlAxV3KUkmmYszsD8zsFTPbYWZ/Z2Z1pehXZDpsfHzP6aJ+ynA2z8bH98SUSKQ4RRd2M2sH/h3Q6e6rgTRwd7H9ikyXw73DF9QuMtOVaudpFZAxsyqgHjhcon5FLrpLWzIX1C4y0xVd2N29C/jPwJtAN9Dn7k8U26/IdLnvlhVkqtMT2jLVae67ZUVMiUSKU4qpmNnAncAy4FKgwcw+PMlyG8xsq5lt7enpKXa1IiVz15p2/vwDV9PeksGA9pYMf/6Bq7XjVMqWuXtxHZj9a+BWd/9E+PwjwPXu/ump3tPZ2ek6CZiIyIUxs23u3nmu5Uoxx/4mcL2Z1ZuZATcBu0rQr4iIRFCKOfYtwMPA88DLYZ+biu1XRESiKckBSu7+BeALpehLRESKo3PFiIhUGBV2EZEKo8IuIlJhVNhFRCqMzu4ogk7bK5VFhV0ST6ftlUqjqRhJPJ22VyqNCrsknk7bK5VGhV0ST6ftlUqjwi6Jp9P2SqXRzlNJvFM7SPWtGKkUKuwiwF1tJ7jrnVug7yA0L4K2SwAVdilPmooRObIDnv0KDPdCU3tw/+xXgnaRMqTCLrLrR1DXApkWsFRwX9cStIuUIRV2kb6DUNc0sa2uKWgXKUMq7CLNi2Ckf2LbSH/QLlKGVNhFVt0OI73B3LoXgvuR3qBdpAyVpLCbWYuZPWxmu81sl5n9ein6FZkWC1bDu+4N5tb7u4L7d90btIuUoVJ93fG/Aj929982sxqgvkT9ikyPBatVyKViFF3YzawJuBH4twDuPgaMFduviIhEU4qpmMuAHuBbZrbdzP7GzBpK0K+IiERQisJeBawFvurua4BB4PNnLmRmG8xsq5lt7enpKcFqRURkMqUo7IeAQ+6+JXz+MEGhn8DdN7l7p7t3tra2lmC1IiIymaLn2N39iJkdNLMV7r4HuAnYWXw0kenz1NNP8frmB2ka7aa/to1l776b9e9ZH3cskUhK9a2Ye4HvhN+I2Q98rET9ilx0Tz39FP1PfRkrZDjMXBpHe+l/6ss8BSruUpZKUtjd/QWgsxR9iUy31zc/iBUy9BPs8++nAQrw9uYHQYVdypCOPJXEaxztZuCMQy8GqKdxtDumRCLFUWGXxOumlUaGJrQ1MkQ32skv5UmFXRLvsXwnzQzRxCCG08QgzQzxWF6zi1KeVNgl8Y7WdfBEYQ2r7A1ut2dZZW/wRGENR+s64o4mEokujSeJd7m/wc2p7ezyJTzHKhoZ4ubUdo774rijiUSiEbsk3g3ZZ+mjnn4acIx+Guijnhuyz8YdTSQSFXZJvI663km/FdNR1xtTIpHiqLBL4i3vWElLamRCW0tqhOUdK2NKJFIcFXZJvFXr7mHd4mraakYxnLaaUdYtrmbVunvijiYSiXaeiixYzeL3/zGLd/0ouIB184rgsni68IaUKRV2EdAVlKSiaCpGRKTCqLCLiFQYFXYRkQqjwi4iUmFU2EVEKowKu4hIhSlZYTeztJltN7N/KFWfIiJy4Uo5Yv8MsKuE/YmISAQlKexmthD4LeBvStGfiIhEV6oR+18BfwQUplrAzDaY2VYz29rT01Oi1YqIyJmKLuxm9n7gLXffdrbl3H2Tu3e6e2drq64lKSJysZRixH4DcIeZHQAeBNab2d+WoF8REYmg6JOAufv9wP0AZvYe4HPu/uFi+xWZTo9u72Lj43s43DvMpS0Z7rtlBXetaY87lkgkOrujJN6j27v4+sM/5Ld5jvaqY3QNzOPrD18H3KHiLmWppIXd3Z8Gni5lnyIX29/+4DE+aw8x1/qpJUuHdbHaX+d//KCKu9Z8Mu54IhdMR55K4t2RfYylqaOYOQOWwcxZmjrKHdnH4o4mEommYiTx1qb2cZI6RqkBOH2/NrUvzlgikWnELolXlbYLaheZ6TRil8Trm/MvWHTsGRptmCry5Egz4BkOzvmNuKOJRKIRuyTeP51opoUh0hQoYKQp0MIQ/3SiOe5oIpFoxC6J987ccxy22dR6jlpyjFLFKFW8M/dc3NFEItGIXRJvAScYoi54Yg7AEHUs4ESMqUSi04hdEq+PepbZYVIYhpOxMZo4yet+adzRRCLRiF0Sb8AayHiWNHkKQJo8Gc8yYA1xRxOJRIVdEm+OD3CUJlI49YyRwjlKE3N8IO5oIpFoKkYSr4ZR6slxglnkSZGmQD05RhiNO5pIJBqxS+INkiFlBcBO31JWYJBMzMlEolFhl8Q76nM47o3gTg1ZcOe4N3LU58QdTSQSFXZJvP1Vl3GgMJ8caao9OPL0QGE++6suizuaSCQq7JJ4e1nE8tQR+mlgDwvpp4HlqSPsZVHc0UQi0c5TSbxF2QNstw4W2HGabIh+r+dVX8ii/IG4o4lEosIuiddR18u+0fm84QsgOPAUw+mo6403mEhERU/FmNkiM/uZme0ys1fM7DOlCCYyXZZ3rKQlNTKhrSU1wvKOlTElEilOKUbsOeAP3f15M2sEtpnZk+6+swR9i1x0q9bdQ0vvA7x9dC9WGMFTdcyd307bunvijiYSSdGF3d27ge7w8YCZ7QLaARV2KRttNaO0zToJuWGoykGNDk6S8lXSb8WY2VJgDbBlktc2mNlWM9va09NTytWKFOeX34C+Q8HjdHVw33coaBcpQyUr7GY2C/ge8Fl37z/zdXff5O6d7t7Z2tpaqtWKFO/1/wvZweCg03RtcJ8dDNpFylBJvhVjZtUERf077v5IKfoUmTaj/Yzk4cRwjryPkbYUs2ugbvRXxiciZaHowm5mBnwD2OXu/6X4SCLTq596fPQIs3BSOAU3RkeNseoFNMUdTiSCUkzF3AD8G2C9mb0Q3m4rQb8i0+K5oTbqGKOBUerD+zrGeG6oLe5oIpGU4lsx/49gVlKkLDVlj1KVKuB2+vgkqrxAU/ZorLlEotKRp5J4V6a6GLM0hgVTMRhuzpWprrijiUSiwi6JV0UeKFCNYwSj9iwWtouUH53dURIvm0pTi5MimFNMAbU42VQ65mQi0aiwS+LVpFKn59ZP8bBdpBzpkyuJV2t58uN2nDqQt6BdpBxpjl0SL+uGOWRJQzjLnvY8WTeq4w4nEoFG7JJ4RwpNmINRAAoYBcyDdpFypMIuibczt4gemii4kfbgyNMemtiZ06XxpDxpKkYS71Dt5VSN5rgi1cUsRjhJHa8W2jlUe3nc0UQi0YhdEi/TftWkF7POtF8VdzSRSFTYJfH633yZfYUFNDHICg7RxCD7Cgvof/PluKOJRKKpGEm8Zbl9tKVOcIxmuphHLVnaUifI5fbFHU0kEo3YJfGabAjHGKUGwnvHaLKhuKOJRKLCLonX7w0YTi1ZAGrJYjj93hBzMpFoVNgl8Xb6Eg77HObRywoOMo9eDvscdvqSuKOJRKLCLom32xfSYd0TvhXTYd3s9oVxRxOJpCSF3cxuNbM9ZrbXzD5fij5FpstKO8SRQjML6WEN+1hID0cKzay0Q3FHE4mkFNc8TQP/HfhN4BDwSzP7obvvLLZvkelwc+Y12se6GLUqBshQQ5aVqS4aa+rijiYSSSlG7NcBe919v7uPAQ8Cd5agX5FpcVVDL+kU1JJjNoPUkiOdCtpFylEpvsfeDhwc9/wQ8M4S9CsyPXKjNFoWqqohVQOFPOSzkBuNO5lIJKUYsU92Ieszr1uAmW0ws61mtrWnp6cEqxUpkara4OY5yA4F96faRMpQKQr7IWD8afAWAofPXMjdN7l7p7t3tra2lmC1IiVSNxeyw8FIHQvus8NBu0gZKkVh/yVwuZktM7Ma4G7ghyXoV2R6mDNCFaMFyBbyjBZghCqwX/nDU6QsFD3H7u45M/t94HEgDXzT3V8pOpnINHnr+HHSXs0Y9eRJkaZAjWfpP36cS+IOJxJBSU4C5u6PAY+Voi+R6dYznCJjGeZykhrLMeZVvM0shodTKuxSlnTkqSTePp/PXE4yatW8TSOjVs1cTrLP58cdTSQSFXZJvF4a6aWBvKeoIUfeU/TSQC+NcUcTiUTnY5fEqyPL5sI1LLfDNDFEv9ezzy+lLjzbo0i5UWGXxOvyeTTbIFv8ytNHYDQxSI+3xBtMJCJNxUji/bhwLc0M0cQghtPEIM0M8ePCtXFHE4lEhV0Sb48vYVP+Nvq8gTbeps8b2JS/jT06H7uUKRV2SbzLL5n8SklTtYvMdJpjl8S7f22B/E+/y1z6qLUsHX6I1anXSa/9k7ijiUSiEbskXs/Tf80VdpA2O06r9dFmx7nCDtLz9F/HHU0kEhV2Sby1+R3MsmEwY4xqMGOWDbM2vyPuaCKRqLBL4jXZEHlS5MNfh1OPm2wo5mQi0aiwS+INpTKk3UmTB4L7tDtDqUzc0UQiUWGXxPMlN3KSOnCo8Rw4nKQOX3Jj3NFEIlFhl8Q7sOxDdPtcHKgmjwPdPpcDyz4UdzSRSFTYJfG+9fMDDFDPEZ/DYeZwxOcwQD3f+vmBuKOJRKLvsUvirR3azEG7hFdYNuFcMWuHNgMfjzWbSBQasUvitdsxBqif0DZAPe12LKZEIsUpqrCb2UYz221mL5nZ981Mp8OTstPl82hk4lcbGxmiy+fFlEikOMWO2J8EVrv7NcCrwP3FRxKZXjq7o1Saogq7uz/h7rnw6S+AhcVHEplee3wJTxTWsMre4HZ7llX2Bk8U1ujsjlK2Srnz9OPAQyXsT2RadNYd5ubcdnb5Ep5jFY0McXNqO2/XLI47mkgk5yzsZvYTYMEkLz3g7j8Il3kAyAHfOUs/G4ANAIsX6xdGZo73soUW+rgutZNZjHCSOl4ttPNetgCfjDueyAU7Z2F39/ee7XUz+yjwfuAmd/ez9LMJ2ATQ2dk55XIi0+3q3A6uTu0nZcHHcjZZrk3toS6na55KeSpqKsbMbgX+GPgNd9cZk6QsLU91UWM5slThGIZTYzmWp7rijiYSSbFz7P8NqAWeNDOAX7j7p4pOJTKNMowBUEMOw3EMH9cuUm6KKuzu3lGqICJxKaSqMR8DLLyB4RRS1bHmEolKR55K4o3WzAGMHGlGqCZHGrCwXaT8qLBL4u0cm8cJn0UVeeoZoYo8J3wWO8d05KmUJ50ETBLvULaZ5elqjnsjaQrkSTFGFYeyzXFHE4lEhV3EjDFqOE4zo1RTS5ZZBNdAFSlHmoqRxGuuyrOlsJIRr6aRIUa8mi2FlTRX5eOOJhKJRuySeFesuJItO/ezxa88fT72FhviihWXxRtMJCIVdkm8VevugcP3MdL3GjWMMUYNdc3zg3aRMqSpGEm8p3a/RX/fcebzNpcS3Pf3Heep3W/FHU0kEhV2SbzeZ75KG8HVkrKkAWjjGL3PfDXOWCKRqbBL4l2Te4kGG8EMxqwaM2iwEa7JvRR3NJFIVNgl8VrSI+Qx8uFoPU+aPEZLeiTmZCLRqLBL4tU0tFCFk6YAQJoCVTg1DbqEr5QnFXZJvKaV66mtbyZtRg1jpM2orW+maeX6uKOJRKKvO4pc+wn6D+7j7eHDWGEUT9cyt/FSGq79RNzJRCJRYZfEe7R7Nt/s/i3WFX5Bux2jKzuPn3Vfz8e7Z3PXZBeFFJnhNBUjibfx8T2M5iaePmA0l2fj43tiSiRSHI3YJfEa+3bzh+nvMtf6qSVLh3Wx2l7nS32/A2ieXcpPSUbsZvY5M3Mz0wmspexsqPsZS1NHMXMGLIOZszR1lA11P4s7mkgkRRd2M1sE/CbwZvFxRKbf+sY3GbQMo9QAxig1DFqG9Y36SEt5KsWI/cvAH3H6vHgi5aUlU83ilgw16eAApZp0msUtGVoyuuaplKeiCruZ3QF0ufuL57HsBjPbamZbe3p6ilmtSGktvJaq3CA1PgZAjY9RlRuEhdfGHEwkmnPuPDWznwCTfenrAeA/ADefz4rcfROwCaCzs1Oje5kxnmq8nYaBZ1nEEdoZY7hQw66BBQw23q5dp1KWzlnY3f29k7Wb2dXAMuBFCy4hthB43syuc/cjJU0pchF96+cH+EghwxGbSy1ZRqmm3zN8++cHWP+euNOJXLjIX3d095eBS049N7MDQKe7HytBLpFp846hzRy0S3jFl51ua2KQdwxtBj4eXzCRiHSAkiReR10vA9RPaBugno663pgSiRSnZIXd3ZdqtC7laHnHSlpSE0/R25IaYXnHypgSiRRHI3ZJvFXr7mHd4mraakYxnLaaUdYtrtY1T6Vs6ZQCIgtWs/j6D7L4l5tgoBsa2+DaDbBgddzJRCJRYRc5sgNe/UeYfzUsuQFG+oPn8zpU3KUsaSpGZNePoK4FMi1gqeC+riVoFylDGrGL9B1k91AjP9/2OgOjWRprq7lh+WxWjh2MO5lIJBqxS+LtGm5my+43GBjNAjAwmmXL7jfYNdwcczKRaFTYJfH+bP/lzCqcpIlBDKeJQWYVTvJn+y+PO5pIJJqKkcTbPDCft+w2bk39Mrg0ns/jocJ72DMwP+5oIpGosEvipc3Y40vYk1/yK+0i5UhTMZJ4eZ/8ZKNTtYvMdCrsknjtLZkLaheZ6VTYJfHuu2UFmer0hLZMdZr7blkRUyKR4qiwS+LdtaadD76j/fScetqMD76jnbvWtMecTCQaFXZJvEe3d/G9bV2n59Tz7nxvWxePbu+KOZlINCrskngbH9/DcDY/oW04m2fj43tiSiRSHBV2SbzDvcMX1C4y0xVd2M3sXjPbY2avmNkXSxFKZDo1Z6ovqF1kpivqACUzWwfcCVzj7qNmdsm53iMy00x1HJKOT5JyVeyI/XeBv3D3UQB3f6v4SCLTq3coe0HtIjNdsYX9CuDdZrbFzJ4xs2tLEUpkOl06xYFIU7WLzHTnLOxm9hMz2zHJ7U6CqZzZwPXAfcB3zSb/A9bMNpjZVjPb2tPTU9J/hEgx1q1svaB2kZnunIXd3d/r7qsnuf0AOAQ84oHngAIwb4p+Nrl7p7t3trbqF0Zmjn94sfuC2kVmumKnYh4F1gOY2RVADXCs2FAi06l3eIo59inaRWa6Yk/b+03gm2a2AxgDPuquU+KJiMSpqMLu7mPAh0uURSQWs+urOTHJN2Bm1+t77FKedOSpJN4Xbr+K6vTEff7VaeMLt18VUyKR4ugKSpJ4p87iuPHxPRzuHebSlgz33bJCZ3eUsqXCLkJQ3FXIpVJoKkZEpMJoxC4CcGQH7PoR9B2E5kWw6nZYsDruVCKRaMQucmQHPPsVGO6Fpvbg/tmvBO0iZUiFXWTXj6CuBTItYKngvq4laBcpQyrsIn0Hoa5pYltdU9AuUoZU2EWaF8FI/8S2kf6gXaQMqbCLrLodRnqDuXUvBPcjvUG7SBlSYRdZsBredW8wt97fFdy/6159K0bKlr7uKAJBEVchlwqhEbuISIVRYRcRqTAq7CIiFUaFXUSkwqiwi4hUGBV2EZEKo8IuIlJhVNhFRCqMufv0r9SsB3hj2ld8/uYBx+IOcR7KJSeUT9ZyyQnlk7VccsLMz7rE3VvPtVAshX2mM7Ot7t4Zd45zKZecUD5ZyyUnlE/WcskJ5ZX1bDQVIyJSYVTYRUQqjAr75DbFHeA8lUtOKJ+s5ZITyidrueSE8so6Jc2xi4hUGI3YRUQqTMUVdjNbZGY/M7NdZvaKmX1mkmVmm9n3zewlM3vOzFaPe+0zZrYjfO9nx7VvNLPd4Xu+b2YtYftSMxs2sxfC29dmQNY/NbOucZluG/fa/Wa218z2mNktMed8aFzGA2b2QthezDatC9f/Yri+/zjJMrXhuvea2RYzW3qu7WNmt4Zte83s8+Pal4V9vBb2WRNXzrP9nM72mYgja9h+wMxeDvNsHdc+x8yeDLfpk2Y2O66cZrZi3DZ7wcz6T32Gi9mmF527V9QNaAPWho8bgVeBK89YZiPwhfDxSuCn4ePVwA6gnuAiJD8BLg9fuxmoCh//JfCX4eOlwI4ZlvVPgc9Nsr4rgReBWmAZsA9Ix5XzjPd/CfiTEmxTA2aFj6uBLcD1ZyzzaeBr4eO7gYfOtn3C2z7gMqAmXObK8D3fBe4OH38N+N0Yc075c5rqMxFX1vC1A8C8Sdb3ReDz4ePPE/6uxZVz3HvTwBGC75IXtU0v9q3iRuzu3u3uz4ePB4BdQPsZi10J/DRcZjew1MzmA6uAX7j7kLvngGeAfxUu90TYBvALYOFMzXoWdwIPuvuou78O7AWuizunmRnwO8DfnSvLeWR1dz8ZPq0Ob2fuSLoT+F/h44eBm8IMU22f64C97r7f3ceAB4E7w/esD/sg7POuuHKe58/pgl2kbXo24/uKdZue8d6bgH3uPpMPrgQqcCpmvPDPrDUE/3OP9yLwgXCZ64AlBIV6B3Cjmc01s3rgNmCyS9V/HPjHcc+Xmdl2M3vGzN49Q7L+vgXTIt8c96dsO3Bw3DKHuMBf/Iu0Td8NHHX318a1Rd6mZpa2YFrnLeBJdz8z6+ntEP5n0wfMZertM1X7XKB33H/4F7Q9L0LO8X0v5Vd/TpN9JuLM6sATZrbNzDaMW2a+u3eHfXUDl8Sc85S7+dXBR+RtejFVbGE3s1nA94DPunv/GS//BTA7/ADcC2wHcu6+i2Ca5UngxwTFKjf+jWb2QNj2nbCpG1js7muAfw/8HzNrijnrV4HlwK+F+b50alWTrP68vxZ1sbYp8CEm/sIUtU3dPe/uv0bwH8t1Nm6+/9Q/ZbK3lbA9rpzBmyb/OU31mYgz6w3uvhZ4H/B7ZnbjhWSaxpxYsO/kDuDvx71e1Da9mCqysJtZNcEH+zvu/siZr7t7v7t/LPwAfARoBV4PX/uGu6919xuB48Br4/r9KPB+4B73YJIt/NPt7fDxNoK5uSvizOruR8MPeAH4Ov/8J+UhJo6WFwKH48oZ9ltFMNJ/aFxfRW3Tcf30Ak8Dt57x0untEK6/Ocw11faZqv0Y0BL2Mb49rpxT/pzO8pmILau7n7p/C/j+uExHzawt7KuNYPQdW87Q+4Dn3f3ouHWUZJteFD4DJvpLeSP4n/fbwF+dZZkWoCZ8/Eng2+NeuyS8XwzsBmaHz28FdgKtZ/TVyj/vDLoM6ALmxJy1bdwyf0AwdwhwFRN3EO3n/HaeXpSc47brMyXcpq1AS/g4A2wG3n/GMr/HxB1o3z3b9iHY6bs/bDu18/Sq8D1/z8Sdp5+OMeeUP6epPhMxZm0AGsNlGoBngVvD5xuZuPP0i3HlHPe+B4GPlWqbXuxb7AFK/g+Cf0nwJ9RLwAvh7TbgU8CnwmV+nWDUuBt4hImFZjNBAX8RuGlc+16CObhTfZ76cHwQeCVc/nng9hmQ9X8DL4f9/vCMD+ADBCPgPcD74swZvvY/T/Uxrq2YbXoNwTTQSwTz+6e+afOfgDvCx3UEBXkv8Bxw2bm2T/jvfTV87YFx7ZeFfewN+6yNK+dUP6dzfSZiynpZ+PN9MfxZj9+mcwl2xL8W3p/vf+oX62dfD7wNNJ+xvsjb9GLfdOSpiEiFqcg5dhGRJFNhFxGpMCrsIiIVRoVdRKTCqLCLiFQYFXYRkQqjwi4iUmFU2EVEKsz/ByD2Yp2IZanPAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(3*np.ones(50),X_transform[0:50])\n",
    "plt.scatter(3*np.ones(50),X_transform[50:100],alpha=.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q. How to reduce the dimension retaining the class separation?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " For this we use LDA. In contrast to PCA, LDA is “supervised” and computes the directions (“linear discriminants”) that will represent the axes that that maximize the separation between multiple classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In LDA, we try to maximise the interclass variance and minimize the intra-class variance. This is an optimisation problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X1[:,0],X1[:,1])\n",
    "plt.scatter(X2[:,0],X2[:,1])\n",
    "plt.xlim([1,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Clasification with LDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.concatenate((X1,X2))\n",
    "y = np.concatenate((np.zeros(50),np.ones(50)))\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "lda = LinearDiscriminantAnalysis(n_components=1,solver='eigen').fit(X,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_tranf = lda.transform(X)\n",
    "X_tranf.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7ff441aef630>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(X_tranf[0:50],np.ones(50))\n",
    "plt.scatter(X_tranf[50:100],np.ones(50))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example :  Two Class Classification using PCA & LDA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import skimage.io as io\n",
    "import skimage.color as clr\n",
    "dir0 = './reception'\n",
    "dir1 = './igloo'\n",
    "\n",
    "list0 = os.listdir(dir0)\n",
    "list1 = os.listdir(dir1)\n",
    "# list1 = use listdir to list files in dir1\n",
    "\n",
    "def rgb2gray(rgb):\n",
    "    \n",
    "    if len(rgb.shape) == 3:\n",
    "        r, g, b = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]\n",
    "        gray = 0.2989 * r + 0.5870 * g + 0.1140 * b\n",
    "        return gray\n",
    "    else: \n",
    "        return rgb\n",
    "\n",
    "X0 = []\n",
    "X1 = []\n",
    "for i in range(len(list0)):\n",
    "    temp1 = io.imread(os.path.join(dir0,list0[i]))\n",
    "    temp = clr.rgb2gray(temp1)\n",
    "    X0.append(temp)\n",
    "X_0 = np.asarray(X0,dtype = np.uint8)\n",
    "\n",
    "for i in range(len(list1)):\n",
    "    temp1 = io.imread(os.path.join(dir1,list1[i]))\n",
    "    temp = clr.rgb2gray(temp1)\n",
    "    X1.append(temp)\n",
    "X_1 = np.asarray(X1, dtype = np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a vector of '0' using np.zeros of size = number of samples in X_0 \n",
    "y_0 = np.zeros([X_0.shape[0],1])\n",
    "\n",
    "# create a vector of '1' using np.ones of size = number of samples in X_1\n",
    "y_1 = np.ones([X_1.shape[0],1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 256, 256)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.concatenate([X_0,X_1],axis=0)\n",
    "y = np.concatenate([y_0,y_1],axis=0)\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1000, 16384)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gopi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score for Logistic Regression : 0.59\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.cross_validation import train_test_split\n",
    "X_downsampled = []\n",
    "for i in range(X.shape[0]):\n",
    "    downsampled_image = np.resize(X[i], [128, 128])\n",
    "    X_downsampled.append(downsampled_image)\n",
    "X_downsampled = np.array(X_downsampled)\n",
    "X_downsampled = X_downsampled.reshape((X_downsampled.shape[0],128*128))\n",
    "print(X_downsampled.shape)\n",
    "\n",
    "trainX, testX, trainY, testY = train_test_split(X_downsampled, y, train_size=0.8, random_state=0)\n",
    "clf = LogisticRegression()\n",
    "clf.fit(trainX,trainY)\n",
    "\n",
    "pred= clf.predict(testX)\n",
    "\n",
    "print(\"Score for Logistic Regression : {}\".format(clf.score(testX,testY)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1000, 16384)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_reshaped = np.reshape(X_downsampled,[X_downsampled.shape[0],-1])\n",
    "X_reshaped.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformed data shape =  (1000, 100)\n"
     ]
    }
   ],
   "source": [
    "pca = PCA(n_components=100,random_state=0)\n",
    "pca.fit(X_reshaped)\n",
    "transform = pca.transform(X_reshaped)\n",
    "print(\"Transformed data shape = \",transform.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PCA(copy=True, iterated_power='auto', n_components=100, random_state=0,\n",
       "  svd_solver='auto', tol=0.0, whiten=False)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score for Logistic Regression : 0.555\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gopi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.cross_validation import train_test_split\n",
    "trainX, testX, trainY, testY = train_test_split(transform, y, train_size=0.8, random_state=0)\n",
    "\n",
    "clf = LogisticRegression()\n",
    "clf.fit(trainX,trainY)\n",
    "\n",
    "pred= clf.predict(testX)\n",
    "\n",
    "print(\"Score for Logistic Regression : {}\".format(clf.score(testX,testY)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gopi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transformed data shape =  (1000, 1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gopi/anaconda3/lib/python3.6/site-packages/sklearn/discriminant_analysis.py:388: UserWarning: Variables are collinear.\n",
      "  warnings.warn(\"Variables are collinear.\")\n"
     ]
    }
   ],
   "source": [
    "lda = LinearDiscriminantAnalysis()\n",
    "lda.fit(X_reshaped,y)\n",
    "transform = lda.transform(X_reshaped)\n",
    "print(\"Transformed data shape = \",transform.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score for Logistic Regression : 0.785\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/gopi/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py:578: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n",
      "  y = column_or_1d(y, warn=True)\n"
     ]
    }
   ],
   "source": [
    "trainX, testX, trainY, testY = train_test_split(transform, y, train_size=0.8, random_state=0)\n",
    "\n",
    "clf = LogisticRegression()\n",
    "clf.fit(trainX,trainY)\n",
    "\n",
    "pred= clf.predict(testX)\n",
    "\n",
    "print(\"Score for Logistic Regression : {}\".format(clf.score(testX,testY)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}