07_LDA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "07 LDA.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyNNaQIso/iV/x8e1B3EbWTc",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/sandipanpaul21/Dimensionality-Reduction-in-Python/blob/master/07_LDA.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t165dl4DQ10Q"
      },
      "source": [
        "#### **Linear Discriminant Analysis (LDA)**\n",
        "- **PCA is an unsupervised** while **LDA is a supervised dimensionality reduction technique**.\n",
        "- PCA has no concern with the class labels. In simple words, PCA summarizes the feature set without relying on the output. PCA tries to find the directions of the maximum variance in the dataset. \n",
        "- In a large feature set, there are many features that are merely duplicate of the other features or have a high correlation with the other features. Such features are basically redundant and can be ignored. \n",
        "- The role of PCA is to find such highly correlated or duplicate features and to come up with a new feature set where there is minimum correlation between the features \n",
        "- In other words feature set with maximum variance between the features. Since the variance between the features doesn't depend upon the output,therefore PCA doesn't take the output labels into account.\n",
        "\n",
        "Unlike PCA, LDA tries to reduce dimensions of the feature set while retaining the information that discriminates output classes. \n",
        "- LDA tries to find a decision boundary around each cluster of a class. \n",
        "- It then projects the data points to new dimensions in a way that the clusters are as separate from each other as possible and the individual elements within a cluster are as close to the centroid of the cluster as possible. \n",
        "- The new dimensions are ranked on the basis of their ability to maximize the distance between the clusters and minimize the distance between the data points within a cluster and their centroids. These new dimensions form the linear discriminants of the feature set."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6C-sRquT7b-"
      },
      "source": [
        "#### **Assumptions of LDA**\n",
        "1. Each feature (variable or dimension or attribute) in the dataset is a gaussian distribution. In other words, each feature in the dataset is shaped like a bell-shaped curve.\n",
        "2. Each feature has the same variance, the value of each feature varies around the mean with the same amount on average.\n",
        "3. Each feature is assumed to be randomly sampled.\n",
        "4. Lack of multicollinearity in independent features. Increase in correlations between independent features and the power of prediction decreases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tSvAP7cMYsO9"
      },
      "source": [
        "#### **How LDA works**\n",
        "1. Compute the **d-dimensional mean vectors** for the different classes from the dataset.\n",
        "2. Compute the **scatter matrices** (in-between-class and within-class scatter matrix).\n",
        "3. Compute the **eigenvectors,e** (e1,e2,...,ed) and **corresponding eigenvalues,λ** (λ1,λ2,...,λd) for the scatter matrices.\n",
        "4. Sort the eigenvectors by decreasing eigenvalues and **choose k eigenvectors with the largest eigenvalues to form a d × k dimensional matrix W** (where every column represents an eigenvector).\n",
        "5. Use this **d × k eigenvector matrix** to transform the samples onto the new subspace. \n",
        "6. This can be summarized by the matrix multiplication: Y= X × W \n",
        "\n",
        "  where, X is a n × d -dimensional matrix representing the n samples and\n",
        "  y are the transformed n × k -dimensional samples in the new subspace\n",
        "\n",
        "  In other word, obtains the new features (i.e. linear discriminants) by taking the dot product of the data and the matrix (created in Step 5)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DPOUEEz6ZfNU"
      },
      "source": [
        "#### **How to Prepare the data for LDA**\n",
        "\n",
        "1. **Outlier Treatment:** Outliers from the data should be removed, outliers will introduce skewness and in-turn computations of mean and variance will be influenced and finally, that will have an impact on LDA computations.\n",
        "\n",
        "2. **Equal Variance:** Standardization of input data, such that it has a mean 0 and a standard deviation of 1.\n",
        "\n",
        "3. **Gaussian distribution:** Univariate analysis of each input feature and if they do not exhibit the gaussian distribution transform them to look like Gaussian distribution(log and root for exponential distributions)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "33Ur5jLrzwnZ"
      },
      "source": [
        "#### **Aim of LDA**\n",
        "\n",
        "**Minimize the Inter-Class Variability:** Inter-class variability refers to including as many similar points as possible in one class. This ensures less number of misclassifications.\n",
        "\n",
        "**Maximize the Distance Between the Mean of Classes:** The classes’ mean is placed as far as possible to ensure high confidence during prediction."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ur_9K6aI0Jlv"
      },
      "source": [
        "#### **Linear Discriminant Analysis (LDA)** \n",
        "- It searches for the projection of a dataset which maximizes the *between class scatter to within class scatter* $\\frac{S_B}{S_W}$ ratio of this projected dataset. \n",
        "- The goal is to project/transform a dataset  using a transformation matrix  such that the ratio of between class scatter to within class scatter of the transformed dataset is maximized. Hence our goal is to find the transformation matrix that accomplishes this.\n",
        "\n",
        "In Fisher's terms:\n",
        "- Find the linear combination such that the between class variance is maximized relative to the within class variance.\n",
        "- LDA aims to find the projection of maximum separability. But slowly. Consider the following illustration which shows a dataset consisting of three different classes. We now want to have the within and between class scatter of this dataset.\n",
        "\n",
        "![An Image](https://python-course.eu/images/Linear_Discriminant_Analysis_concept_illustration_800w.webp)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2HITpc9EHd-2"
      },
      "source": [
        "# Libraries \n",
        "from sklearn import datasets \n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")\n",
        "import matplotlib.pyplot as plt\n",
        "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
        "from sklearn.preprocessing import StandardScaler"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_hSgw_mzHuwz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "7bcc047f-f0b2-4f6d-f5f4-307aeda3fef8"
      },
      "source": [
        "# Step 1 \n",
        "# Importing required libraries in our Jupyter notebook\n",
        "\n",
        "# Iris Dataset for Classification\n",
        "# Load Dataset\n",
        "iris = datasets.load_iris()\n",
        "# Convert to DataFrame\n",
        "iris_pd = pd.DataFrame(iris.data)\n",
        "# Feature Name\n",
        "iris_pd.columns = iris.feature_names\n",
        "# Target Variable\n",
        "iris_pd[\"Class\"] = iris.target\n",
        "dataset = iris_pd\n",
        "dataset.head()"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>sepal length (cm)</th>\n",
              "      <th>sepal width (cm)</th>\n",
              "      <th>petal length (cm)</th>\n",
              "      <th>petal width (cm)</th>\n",
              "      <th>Class</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>5.1</td>\n",
              "      <td>3.5</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>4.9</td>\n",
              "      <td>3.0</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>4.7</td>\n",
              "      <td>3.2</td>\n",
              "      <td>1.3</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>4.6</td>\n",
              "      <td>3.1</td>\n",
              "      <td>1.5</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>5.0</td>\n",
              "      <td>3.6</td>\n",
              "      <td>1.4</td>\n",
              "      <td>0.2</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   sepal length (cm)  sepal width (cm)  ...  petal width (cm)  Class\n",
              "0                5.1               3.5  ...               0.2      0\n",
              "1                4.9               3.0  ...               0.2      0\n",
              "2                4.7               3.2  ...               0.2      0\n",
              "3                4.6               3.1  ...               0.2      0\n",
              "4                5.0               3.6  ...               0.2      0\n",
              "\n",
              "[5 rows x 5 columns]"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7mXk33AWH6eJ"
      },
      "source": [
        "# Loading the dataset and separating the dependent variable and independent variable in variables \n",
        "# named as “dependentVaraible” and “independentVariables” respectively\n",
        "\n",
        "# Data Preprocessing\n",
        "independentVariables = dataset.iloc[:, 0:4].values\n",
        "dependentVariables = dataset['Class'].values\n",
        "\n",
        "# Label Encoding\n",
        "# We did Label Encoding because we have label 0\n",
        "# So many times when 0 get multiplied answer varies\n",
        "# Therefore we added +1, 0 became 1, 1 became 2, 2 became 3\n",
        "enc = LabelEncoder()\n",
        "label_encoder = enc.fit(dependentVariables)\n",
        "dependentVariables = label_encoder.transform(dependentVariables) + 1\n",
        "label_dict = {1: '0', 2: '1', 3:'2'}"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xkjsmHoYeORE",
        "outputId": "67231a09-4099-459b-9661-df34eb880b97"
      },
      "source": [
        "# Step 1: \n",
        "# Computing the d-dimensional mean vectors\n",
        "# In this first step, we will start off with a simple computation of the mean vectors mmi, (i=0,1,2) of the 3 different flower classes:\n",
        "# Mean vector consists of the means of each variable\n",
        "\n",
        "np.set_printoptions(precision=4)\n",
        "\n",
        "mean_vectors = []\n",
        "for cl in range(1,4):\n",
        "  mean_vectors.append(np.mean(independentVariables[dependentVariables==cl], axis=0))\n",
        "  print('Mean Vector class %s: %s\\n' %(cl, mean_vectors[cl-1]))\n",
        "\n",
        "# Inference \n",
        "# 5.006 is the Mean of Column 1 for Class 0 \n",
        "# 3.428 is the Mean of Column 2 for Class 0"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Vector class 1: [5.006 3.428 1.462 0.246]\n",
            "\n",
            "Mean Vector class 2: [5.936 2.77  4.26  1.326]\n",
            "\n",
            "Mean Vector class 3: [6.588 2.974 5.552 2.026]\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 173
        },
        "id": "2oXnvTGNxV8y",
        "outputId": "215262b0-43a5-47aa-bac7-d634c2afc7bf"
      },
      "source": [
        "# Another way to check Mean Vector of Target Class. i.e, \"Class\"\n",
        "dataset.groupby(by=[\"Class\"]).mean()"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>sepal length (cm)</th>\n",
              "      <th>sepal width (cm)</th>\n",
              "      <th>petal length (cm)</th>\n",
              "      <th>petal width (cm)</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Class</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>5.006</td>\n",
              "      <td>3.428</td>\n",
              "      <td>1.462</td>\n",
              "      <td>0.246</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>5.936</td>\n",
              "      <td>2.770</td>\n",
              "      <td>4.260</td>\n",
              "      <td>1.326</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>6.588</td>\n",
              "      <td>2.974</td>\n",
              "      <td>5.552</td>\n",
              "      <td>2.026</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)\n",
              "Class                                                                          \n",
              "0                  5.006             3.428              1.462             0.246\n",
              "1                  5.936             2.770              4.260             1.326\n",
              "2                  6.588             2.974              5.552             2.026"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8LH8PFoSuO_s",
        "outputId": "0b04079a-f17c-4991-c2a6-804d89b363a6"
      },
      "source": [
        "# Step 2\n",
        "# Computing the Scatter Matrices\n",
        "# Now, we will compute the two 4x4-dimensional matrices: The within-class and the between-class scatter matrix.\n",
        "\n",
        "S_W = np.zeros((4,4))\n",
        "for cl,mv in zip(range(1,4), mean_vectors):\n",
        "    class_sc_mat = np.zeros((4,4))                  # scatter matrix for every class\n",
        "    for row in independentVariables[dependentVariables == cl]:\n",
        "        row, mv = row.reshape(4,1), mv.reshape(4,1) # make column vectors\n",
        "        class_sc_mat += (row-mv).dot((row-mv).T)\n",
        "    S_W += class_sc_mat                             # sum class scatter matrices\n",
        "print('within-class Scatter Matrix:\\n', S_W)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "within-class Scatter Matrix:\n",
            " [[38.9562 13.63   24.6246  5.645 ]\n",
            " [13.63   16.962   8.1208  4.8084]\n",
            " [24.6246  8.1208 27.2226  6.2718]\n",
            " [ 5.645   4.8084  6.2718  6.1566]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YsWT36AFuzy1",
        "outputId": "65a29000-75ae-471a-bc3b-1007610cbebd"
      },
      "source": [
        "overall_mean = np.mean(independentVariables, axis=0)\n",
        "\n",
        "S_B = np.zeros((4,4))\n",
        "for i,mean_vec in enumerate(mean_vectors):  \n",
        "    n = independentVariables[dependentVariables==i+1,:].shape[0]\n",
        "    mean_vec = mean_vec.reshape(4,1) # make column vector\n",
        "    overall_mean = overall_mean.reshape(4,1) # make column vector\n",
        "    S_B += n * (mean_vec - overall_mean).dot((mean_vec - overall_mean).T)\n",
        "\n",
        "print('between-class Scatter Matrix:\\n', S_B)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "between-class Scatter Matrix:\n",
            " [[ 63.2121 -19.9527 165.2484  71.2793]\n",
            " [-19.9527  11.3449 -57.2396 -22.9327]\n",
            " [165.2484 -57.2396 437.1028 186.774 ]\n",
            " [ 71.2793 -22.9327 186.774   80.4133]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RVJ89ifSvDJl",
        "outputId": "6a46e2aa-14e9-4af7-83d9-8bc34ee81f68"
      },
      "source": [
        "# Step 3\n",
        "# Find Eigen Value And Eigen Vector for within-class Scatter Matrix and between-class Scatter Matrix \n",
        "# It's 4*4 so we will have 4 eigen values and 4 corresponding matrix\n",
        "\n",
        "eig_vals, eig_vecs = np.linalg.eig(np.linalg.inv(S_W).dot(S_B))\n",
        "\n",
        "for i in range(len(eig_vals)):\n",
        "    eigvec_sc = eig_vecs[:,i].reshape(4,1)   \n",
        "    print('\\nEigenvector {}: \\n{}'.format(i+1, eigvec_sc.real))\n",
        "    print('Eigenvalue {:}: {:.2e}'.format(i+1, eig_vals[i].real))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Eigenvector 1: \n",
            "[[ 0.2087]\n",
            " [ 0.3862]\n",
            " [-0.554 ]\n",
            " [-0.7074]]\n",
            "Eigenvalue 1: 3.22e+01\n",
            "\n",
            "Eigenvector 2: \n",
            "[[-0.0065]\n",
            " [-0.5866]\n",
            " [ 0.2526]\n",
            " [-0.7695]]\n",
            "Eigenvalue 2: 2.85e-01\n",
            "\n",
            "Eigenvector 3: \n",
            "[[ 0.885 ]\n",
            " [-0.2977]\n",
            " [-0.2764]\n",
            " [-0.2274]]\n",
            "Eigenvalue 3: -1.74e-15\n",
            "\n",
            "Eigenvector 4: \n",
            "[[-0.2137]\n",
            " [ 0.397 ]\n",
            " [ 0.4597]\n",
            " [-0.7651]]\n",
            "Eigenvalue 4: -9.15e-15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p4002D-jvMYF",
        "outputId": "4737d972-4363-4859-c002-31a5d43e805c"
      },
      "source": [
        "# Step 4\n",
        "# Selecting linear discriminants for the new feature subspace\n",
        "# The eigenvectors with the lowest eigenvalues bear the least information about the distribution of the data, \n",
        "# and those are the ones we want to drop.\n",
        "# The common approach is to rank the eigenvectors from highest to lowest corresponding eigenvalue and choose the top k eigenvectors.\n",
        "\n",
        "# 4.1. Sorting the eigenvectors by decreasing eigenvalues\n",
        "# Make a list of (eigenvalue, eigenvector) tuples\n",
        "eig_pairs = [(np.abs(eig_vals[i]), eig_vecs[:,i]) for i in range(len(eig_vals))]\n",
        "\n",
        "# Sort the (eigenvalue, eigenvector) tuples from high to low\n",
        "eig_pairs = sorted(eig_pairs, key=lambda k: k[0], reverse=True)\n",
        "\n",
        "# Visually confirm that the list is correctly sorted by decreasing eigenvalues\n",
        "print('Eigenvalues in decreasing order:\\n')\n",
        "for i in eig_pairs:\n",
        "    print(i[0])"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Eigenvalues in decreasing order:\n",
            "\n",
            "32.19192919827802\n",
            "0.2853910426230726\n",
            "9.153009723648236e-15\n",
            "1.741606802500899e-15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nJE1W9sovN3Z",
        "outputId": "1484d298-0bab-4de5-b415-93822de269fb"
      },
      "source": [
        "# 4.2. \n",
        "# “explained variance” as percentage:\n",
        "\n",
        "print('Variance explained:\\n')\n",
        "eigv_sum = sum(eig_vals)\n",
        "for i,j in enumerate(eig_pairs):\n",
        "    print('eigenvalue {0:}: {1:.2%}'.format(i+1, (j[0]/eigv_sum).real))\n",
        "\n",
        "# Inference\n",
        "# The first eigenpair is by far the most informative one, \n",
        "# and we won’t loose much information if we would form a 1D-feature spaced based on this eigenpair."
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Variance explained:\n",
            "\n",
            "eigenvalue 1: 99.12%\n",
            "eigenvalue 2: 0.88%\n",
            "eigenvalue 3: 0.00%\n",
            "eigenvalue 4: 0.00%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEi8EcX-vQmJ",
        "outputId": "bc6c0f2d-44ae-44ad-a599-3a65a360776e"
      },
      "source": [
        "# 4.3. \n",
        "# Choosing k eigenvectors with the largest eigenvalues\n",
        "# After sorting the eigenpairs by decreasing eigenvalues, \n",
        "# it is now time to construct our d×k-dimensional eigenvector matrix WW \n",
        "# here 4×2: based on the 2 most informative eigenpairs\n",
        "# and thereby reducing the initial 4-dimensional feature space into a 2-dimensional feature subspace.\n",
        "\n",
        "W = np.hstack((eig_pairs[0][1].reshape(4,1), eig_pairs[1][1].reshape(4,1)))\n",
        "print('Matrix W:\\n', W.real)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Matrix W:\n",
            " [[ 0.2087 -0.0065]\n",
            " [ 0.3862 -0.5866]\n",
            " [-0.554   0.2526]\n",
            " [-0.7074 -0.7695]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LDi6fSxLB1UR",
        "outputId": "e58182aa-6012-4669-9cd2-063499bc63e0"
      },
      "source": [
        "# Step 5\n",
        "# Transforming the samples onto the new subspace\n",
        "# In the last step, we use the 4×2-dimensional matrix W \n",
        "# that we just computed to transform our samples onto the new subspace via the equation\n",
        "# Y= X × W.\n",
        "# where X is a n × d - dimensional matrix representing the n samples\n",
        "# Y are the transformed n×k-dimensional samples in the new subspace.\n",
        "\n",
        "X_lda = independentVariables.dot(W)\n",
        "assert X_lda.shape == (150,2), \"The matrix is not 150x2 dimensional.\"\n",
        "print(\"New IRIS Dataset reduced to 2 Dimension (top 10 rows)\")\n",
        "print(X_lda[:10])"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "New IRIS Dataset reduced to 2 Dimension (top 10 rows)\n",
            "[[ 1.4992 -1.8868]\n",
            " [ 1.2644 -1.5921]\n",
            " [ 1.3553 -1.7334]\n",
            " [ 1.185  -1.6236]\n",
            " [ 1.517  -1.9448]\n",
            " [ 1.4086 -2.2015]\n",
            " [ 1.2855 -1.9018]\n",
            " [ 1.3843 -1.8022]\n",
            " [ 1.1214 -1.5302]\n",
            " [ 1.3183 -1.5486]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lcEqTtSTFEUA",
        "outputId": "d312bdba-b6ea-436a-ec93-3450709e2ab6"
      },
      "source": [
        "# Step 6\n",
        "# LDA Iris Dataset\n",
        "\n",
        "data=pd.DataFrame(X_lda)\n",
        "data['class']=dependentVariables\n",
        "data.columns=[\"LD1\",\"LD2\",\"class\"]\n",
        "print(\"New LDA IRIS Dataset\")\n",
        "print(data.head())"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "New LDA IRIS Dataset\n",
            "        LD1       LD2  class\n",
            "0  1.499210 -1.886754      1\n",
            "1  1.264360 -1.592143      1\n",
            "2  1.355253 -1.733415      1\n",
            "3  1.184956 -1.623588      1\n",
            "4  1.516956 -1.944762      1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 385
        },
        "id": "Fdv4PZ62LmGG",
        "outputId": "5b7edf20-3163-4ff9-8dbe-d4e5323100dd"
      },
      "source": [
        "# Plotting the LDA\n",
        "\n",
        "markers = ['s', 'x','o']\n",
        "colors = ['r', 'b','g']\n",
        "sns.lmplot(x=\"LD1\", y=\"LD2\", data=data, hue='class', markers=markers,fit_reg=False,legend=False)\n",
        "plt.legend(loc='upper center')\n",
        "plt.title('LDA Step by Step Plot')\n",
        "plt.show()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u1dEJ6QbFzMi",
        "outputId": "911f63d0-e231-4849-8aa3-36b24dad4b05"
      },
      "source": [
        "# LDA Through Python\n",
        "\n",
        "# Perform standard scaling on model features\n",
        "scaler=StandardScaler()\n",
        "X_std=scaler.fit_transform(independentVariables)\n",
        "\n",
        "# Fit LDA\n",
        "lda = LinearDiscriminantAnalysis(n_components=2,solver='eigen')\n",
        "lda"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearDiscriminantAnalysis(n_components=2, priors=None, shrinkage=None,\n",
              "                           solver='eigen', store_covariance=False, tol=0.0001)"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MB7y0yEbKXI8",
        "outputId": "a171f38b-9591-4e19-c7fa-eaf14449d88f"
      },
      "source": [
        "# LDA IRIS Dataset \n",
        "\n",
        "X_train_lda = lda.fit_transform(X_std, dependentVariables)\n",
        "data=pd.DataFrame(X_train_lda)\n",
        "data['class']=dependentVariables\n",
        "data.columns=[\"LD1\",\"LD2\",\"class\"]\n",
        "print(\"New LDA IRIS Dataset\")\n",
        "print(data.head())"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "New LDA IRIS Dataset\n",
            "        LD1       LD2  class\n",
            "0  8.143648  0.303471      1\n",
            "1  7.201062 -0.794647      1\n",
            "2  7.565869 -0.268079      1\n",
            "3  6.882372 -0.677440      1\n",
            "4  8.214873  0.519686      1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 383
        },
        "id": "mEojfGmrLNgi",
        "outputId": "74c1fb7d-8f02-4268-bbc9-cf5321cec1a3"
      },
      "source": [
        "# Plotting the LDA\n",
        "\n",
        "markers = ['s', 'x','o']\n",
        "colors = ['r', 'b','g']\n",
        "sns.lmplot(x=\"LD1\", y=\"LD2\", data=data, hue='class', markers=markers,fit_reg=False,legend=False)\n",
        "plt.legend(loc='upper center')\n",
        "plt.title('LDA Library Plot')\n",
        "plt.show()\n",
        "\n",
        "# Inference \n",
        "# Both Step by Step and Library gave similar plot\n",
        "# Only the plot got flipped upside down\n",
        "# And the scale got changed"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 360x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}