21_Feature_Engineering.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "21 Feature Engineering.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMjH/qOaqf4svRvDHnJBtq3",
      "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/EDA-in-Python/blob/main/21_Feature_Engineering.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jC2s8V3e6t8V"
      },
      "source": [
        "# Feature Engineering \n",
        "\n",
        "# It helps in increasing the accuracy of the model as by tweaking the features of the data\n",
        "# the performance of the models can be improved which ultimately influences the final result.\n",
        "\n",
        "# Normally Feature Engineering contains 3 Major Steps : \n",
        "# 1.Feature Transformation\n",
        "# 2.Feature Scaling\n",
        "# 3.Feature Construction\n",
        "\n",
        "# 1. Feature Transformation\n",
        "# Features are transformed by replacing the observations of the feature by a function\n",
        "# Sometimes the datasets are not normally distributed and in such circumstances\n",
        "# for the normal functioning of various statistical and other machine learning algorithms\n",
        "# feature transformation is performed to normalize the data\n",
        "# The common application of them is when dealing with predictive models \n",
        "# such as Linear Regression where we need to normalize the data if the data is otherwise.\n",
        "# Methods Used: 1.Log Transformation 2.Square Root 3.Cube Root and 4.Box-Cox Transformation\n",
        "\n",
        "# 2. Feature Scaling\n",
        "# Feature scaling is conducted to standardize the independent features\n",
        "# This is done because the range of raw data may vary widely. \n",
        "# Some predictive models such as KNN and K-means consider Euclidean distance \n",
        "# it is important for them to have the features on the same scale.\n",
        "# Method Used: Min-Max Scaler \n",
        "\n",
        "# 3. Feature Construction\n",
        "# It is a process of creating features based on the original descriptors\n",
        "# This helps in building more efficient features for building predictive models\n",
        "# Methods Used: 1.Binning and 2.Encoding"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yd60rqCQ7BgJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "outputId": "3dfecb7c-fc7d-4f07-c4fd-88d81f95dd90"
      },
      "source": [
        "# Import Libraries\n",
        "\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib \n",
        "%matplotlib inline\n",
        "from sklearn import datasets\n",
        "import sklearn as sk\n",
        "import seaborn as sns\n",
        "from scipy import stats\n",
        "from sklearn.preprocessing import MinMaxScaler as min_max\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "from sklearn.preprocessing import LabelEncoder"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KPt69x2a7tHs",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "64bfa584-5364-459d-88e8-ae6614e8a721"
      },
      "source": [
        "# Load the Datasets (For indepth analysis please refer to Part O1 All About Datasets)\n",
        "\n",
        "# Boston Dataset\n",
        "boston = datasets.load_boston()\n",
        "boston_pd = pd.DataFrame(boston.data)\n",
        "boston_pd.columns = boston.feature_names\n",
        "boston_pd[\"MEDV\"] = boston.target\n",
        "boston_pd.head()"
      ],
      "execution_count": null,
      "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>CRIM</th>\n",
              "      <th>ZN</th>\n",
              "      <th>INDUS</th>\n",
              "      <th>CHAS</th>\n",
              "      <th>NOX</th>\n",
              "      <th>RM</th>\n",
              "      <th>AGE</th>\n",
              "      <th>DIS</th>\n",
              "      <th>RAD</th>\n",
              "      <th>TAX</th>\n",
              "      <th>PTRATIO</th>\n",
              "      <th>B</th>\n",
              "      <th>LSTAT</th>\n",
              "      <th>MEDV</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.00632</td>\n",
              "      <td>18.0</td>\n",
              "      <td>2.31</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.538</td>\n",
              "      <td>6.575</td>\n",
              "      <td>65.2</td>\n",
              "      <td>4.0900</td>\n",
              "      <td>1.0</td>\n",
              "      <td>296.0</td>\n",
              "      <td>15.3</td>\n",
              "      <td>396.90</td>\n",
              "      <td>4.98</td>\n",
              "      <td>24.0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0.02731</td>\n",
              "      <td>0.0</td>\n",
              "      <td>7.07</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.469</td>\n",
              "      <td>6.421</td>\n",
              "      <td>78.9</td>\n",
              "      <td>4.9671</td>\n",
              "      <td>2.0</td>\n",
              "      <td>242.0</td>\n",
              "      <td>17.8</td>\n",
              "      <td>396.90</td>\n",
              "      <td>9.14</td>\n",
              "      <td>21.6</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0.02729</td>\n",
              "      <td>0.0</td>\n",
              "      <td>7.07</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.469</td>\n",
              "      <td>7.185</td>\n",
              "      <td>61.1</td>\n",
              "      <td>4.9671</td>\n",
              "      <td>2.0</td>\n",
              "      <td>242.0</td>\n",
              "      <td>17.8</td>\n",
              "      <td>392.83</td>\n",
              "      <td>4.03</td>\n",
              "      <td>34.7</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0.03237</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.18</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.458</td>\n",
              "      <td>6.998</td>\n",
              "      <td>45.8</td>\n",
              "      <td>6.0622</td>\n",
              "      <td>3.0</td>\n",
              "      <td>222.0</td>\n",
              "      <td>18.7</td>\n",
              "      <td>394.63</td>\n",
              "      <td>2.94</td>\n",
              "      <td>33.4</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0.06905</td>\n",
              "      <td>0.0</td>\n",
              "      <td>2.18</td>\n",
              "      <td>0.0</td>\n",
              "      <td>0.458</td>\n",
              "      <td>7.147</td>\n",
              "      <td>54.2</td>\n",
              "      <td>6.0622</td>\n",
              "      <td>3.0</td>\n",
              "      <td>222.0</td>\n",
              "      <td>18.7</td>\n",
              "      <td>396.90</td>\n",
              "      <td>5.33</td>\n",
              "      <td>36.2</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "      CRIM    ZN  INDUS  CHAS    NOX  ...    TAX  PTRATIO       B  LSTAT  MEDV\n",
              "0  0.00632  18.0   2.31   0.0  0.538  ...  296.0     15.3  396.90   4.98  24.0\n",
              "1  0.02731   0.0   7.07   0.0  0.469  ...  242.0     17.8  396.90   9.14  21.6\n",
              "2  0.02729   0.0   7.07   0.0  0.469  ...  242.0     17.8  392.83   4.03  34.7\n",
              "3  0.03237   0.0   2.18   0.0  0.458  ...  222.0     18.7  394.63   2.94  33.4\n",
              "4  0.06905   0.0   2.18   0.0  0.458  ...  222.0     18.7  396.90   5.33  36.2\n",
              "\n",
              "[5 rows x 14 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ltq2p5CK8Da_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 287
        },
        "outputId": "b468d8db-28dd-4df3-8ce9-6d473b9906a4"
      },
      "source": [
        "# Skewness\n",
        "\n",
        "# Spreadness of the Distribution\n",
        "# If Skewness = 0, data is perfectly symmetrical / Normally Distributed\n",
        "# If Skewness is less than -1 or greater +1, distribution is highly skewed\n",
        "# If Skewness is between -1 and -0.5 or between 0.5 and 1, distribution is moderately skewed\n",
        "# If Skewness is between -0.5 and 0.5 then it is approximately symmetric  \n",
        "\n",
        "boston_pd.skew()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "CRIM       5.223149\n",
              "ZN         2.225666\n",
              "INDUS      0.295022\n",
              "CHAS       3.405904\n",
              "NOX        0.729308\n",
              "RM         0.403612\n",
              "AGE       -0.598963\n",
              "DIS        1.011781\n",
              "RAD        1.004815\n",
              "TAX        0.669956\n",
              "PTRATIO   -0.802325\n",
              "B         -2.890374\n",
              "LSTAT      0.906460\n",
              "MEDV       1.108098\n",
              "dtype: float64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k1WEjBTW8seq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b360f7d1-d1a8-4f40-b2da-3e96aa3453dc"
      },
      "source": [
        "# Check for one variable\n",
        "print(\"Skewness of 'CRIM' Column is \",boston_pd['CRIM'].skew())\n",
        "\n",
        "# Inference : 5.22 which is highly skewed. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Skewness of 'CRIM' Column is  5.223148798243851\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IgJPwHVN9FqR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "100c190b-72a5-467b-f740-641e3741d562"
      },
      "source": [
        "# Plot Bar Graph\n",
        "\n",
        "# By Plotting histogram we can check the skewness of the data.\n",
        "sns.distplot(boston_pd['CRIM'])\n",
        "\n",
        "# Inference : \n",
        "# Right Skewed\n",
        "# It is evident how skewed the data is. \n",
        "# We can now apply various transformation and see how it affects the skewness of the data."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f0f75489d30>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qi4zmwWW9ZjR",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "55380c45-7ad1-475f-ff49-ccbe3ee810a7"
      },
      "source": [
        "# Log Transformation\n",
        "\n",
        "# Among the most commonly used methods of transformation, \n",
        "# Log Transformation takes the natural logarithm of the variable \n",
        "# which helps in making the distribution normal. \n",
        "# We do Log transformation on the variable, to reduce skewness and normalize the data\n",
        "\n",
        "boston_pd['CRIM_Log'] = np.log(boston_pd['CRIM'])\n",
        "print('After LOG TRANSFORMATION, Skewness is :',boston_pd['CRIM_Log'].skew().round(3))\n",
        "print('\\n')\n",
        "sns.distplot(boston_pd['CRIM_Log'])\n",
        "\n",
        "# Inference : \n",
        "# The distribution certainly now appears to be much more normal. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "After LOG TRANSFORMATION, Skewness is : 0.406\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f0f75303048>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Js8JagGN-Ttf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "99f08375-a368-4577-bfe8-7d74e654acb4"
      },
      "source": [
        "# Square-Root Transformation\n",
        "\n",
        "# Another popular method of transformation is Square root transformation \n",
        "# which helps in normalizing the data.\n",
        "\n",
        "boston_pd['CRIM_Sqrt'] = np.sqrt(boston_pd['CRIM'])\n",
        "print('After SQUARE ROOT TRANSFORMATION, Skewness is :',boston_pd['CRIM_Sqrt'].skew().round(3))\n",
        "print('\\n')\n",
        "sns.distplot(boston_pd['CRIM_Sqrt'])\n",
        "\n",
        "# Inference : \n",
        "# The distribution certainly now appears to be much more normal."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "After SQUARE ROOT TRANSFORMATION, Skewness is : 2.024\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f0f74e75588>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rydwdo3I_uUx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 352
        },
        "outputId": "9ee7b778-9234-46ef-cca0-cc0de8c9e5b3"
      },
      "source": [
        "# Cube-Root Transformation\n",
        "# Apart form Log and Square-Root transformation, Cube-Root transformation can also be tried.\n",
        "\n",
        "boston_pd['CRIM_cbrt'] = np.cbrt(boston_pd['CRIM'])\n",
        "print('After CUBE ROOT TRANSFORMATION, Skewness is :',boston_pd['CRIM_cbrt'].skew().round(3))\n",
        "print('\\n')\n",
        "sns.distplot(boston_pd['CRIM_cbrt'])\n",
        "\n",
        "# Inference : \n",
        "# The distribution certainly now appears to be much more normal."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "After CUBE ROOT TRANSFORMATION, Skewness is : 1.363\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f0f82463748>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ifkvV5vJAKdW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 337
        },
        "outputId": "2880c41d-a651-4e62-f142-fc4e4360b873"
      },
      "source": [
        "# Box Cox Transformation\n",
        "\n",
        "CRIM_BoxCox = stats.boxcox(boston_pd['CRIM'])[0]\n",
        "Variable = pd.Series(CRIM_BoxCox)\n",
        "\n",
        "print(\"After BoxCox Transformation, Skewness is \",Variable.skew().round(3))\n",
        "print('\\n')\n",
        "sns.distplot(Variable)\n",
        "\n",
        "# Inference :\n",
        "# So the best one is BoxCox Transformation because of LOWEST SKEWNESS out of all three"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "After BoxCox Transformation, Skewness is  0.094\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.axes._subplots.AxesSubplot at 0x7f0f74de9940>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rD3_3KvtAsmG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 222
        },
        "outputId": "f19e6494-699e-48e6-c59a-82803b78081d"
      },
      "source": [
        "# All the Skewness Value Calculated\n",
        "print(\"Comparing all Skewness values\")\n",
        "pd.DataFrame([boston_pd['CRIM'].skew(),boston_pd['CRIM_Log'].skew(),\n",
        "              boston_pd['CRIM_Sqrt'].skew(),\n",
        "              boston_pd['CRIM_cbrt'].skew(),Variable.skew()],\n",
        "             index=['Normal','Log','Square Root','Cube Root','Box Cox'],\n",
        "             columns = [\"CRIM Skewness\"])\n",
        "\n",
        "# Inference : Best transformations can be Log or Box Cox Transformation"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Comparing all Skewness values\n"
          ],
          "name": "stdout"
        },
        {
          "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>CRIM Skewness</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>Normal</th>\n",
              "      <td>5.223149</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Log</th>\n",
              "      <td>0.405934</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Square Root</th>\n",
              "      <td>2.024382</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Cube Root</th>\n",
              "      <td>1.362514</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Box Cox</th>\n",
              "      <td>0.093649</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "             CRIM Skewness\n",
              "Normal            5.223149\n",
              "Log               0.405934\n",
              "Square Root       2.024382\n",
              "Cube Root         1.362514\n",
              "Box Cox           0.093649"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a8exGVYIBXN0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a4aab017-bd63-4b39-ca06-e6c3aaffbb0d"
      },
      "source": [
        "# Min Max Scaler\n",
        "\n",
        "# MinMaxScaler method is one of the methods of standardizing \n",
        "# the data where values are made to lie between 0 and 1.\n",
        "\n",
        "# Initialization\n",
        "# We begin with initializing the min_max function.\n",
        "\n",
        "scaled = min_max()\n",
        "scaled\n",
        "\n",
        "# Inference : Range is set from 0 to 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MinMaxScaler(copy=True, feature_range=(0, 1))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hf4DYUNVCkBh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "02d949f1-aa9b-46df-a6b0-627bd4c120ee"
      },
      "source": [
        "# Fit min_max function\n",
        "\n",
        "# After initialization, we fit the mix_max function on the numerical variable which we need to standardize.\n",
        "scaled.fit(boston_pd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "MinMaxScaler(copy=True, feature_range=(0, 1))"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bR7_gGLPDblK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 251
        },
        "outputId": "8a6cb52f-46cb-4ef7-f822-a106d4268743"
      },
      "source": [
        "# Generating Output\n",
        "\n",
        "# Once the function is fit, we can generate output which will have the standardized values \n",
        "boston_pd_scaled = scaled.transform(boston_pd)\n",
        "boston_pd_scaled"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.00000000e+00, 1.80000000e-01, 6.78152493e-02, ...,\n",
              "        0.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n",
              "       [2.35922539e-04, 0.00000000e+00, 2.42302053e-01, ...,\n",
              "        1.53211022e-01, 9.16892109e-03, 2.71662926e-02],\n",
              "       [2.35697744e-04, 0.00000000e+00, 2.42302053e-01, ...,\n",
              "        1.53134329e-01, 9.16245030e-03, 2.71491104e-02],\n",
              "       ...,\n",
              "       [6.11892474e-04, 0.00000000e+00, 4.20454545e-01, ...,\n",
              "        2.36925934e-01, 1.78544915e-02, 4.86617589e-02],\n",
              "       [1.16072990e-03, 0.00000000e+00, 4.20454545e-01, ...,\n",
              "        2.98671060e-01, 2.68939834e-02, 6.86206232e-02],\n",
              "       [4.61841693e-04, 0.00000000e+00, 4.20454545e-01, ...,\n",
              "        2.10953574e-01, 1.47799292e-02, 4.13702247e-02]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7Ei1kK1TDvrK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "03ef2d53-5e52-40df-f486-572e7924f356"
      },
      "source": [
        "# Binning\n",
        "\n",
        "# This method is used to create bins for continuous variables \n",
        "# where continuous variables are converted to categorical variables.\n",
        "# Two types Binning - 1. Automatic & Manual Binning\n",
        "\n",
        "# For this Analysis we will only take 'AGE' Column in Boston Dataset\n",
        "AgeData = boston_pd[['AGE']]\n",
        "print(type(AgeData))\n",
        "print(AgeData.dtypes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "AGE    float64\n",
            "dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZWKDS5mQGfem",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 332
        },
        "outputId": "f71865b7-069d-4e22-dec2-c0cb5c56beba"
      },
      "source": [
        "# Automatic Binning\n",
        "\n",
        "# Bins are created automatically \n",
        "# we do not explicitly mention how the bins are to be created\n",
        "\n",
        "AgeData['Auto_BINS'] = pd.cut(AgeData['AGE'],4)\n",
        "AgeData.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:6: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  \n"
          ],
          "name": "stderr"
        },
        {
          "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>AGE</th>\n",
              "      <th>Auto_BINS</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>65.2</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>78.9</td>\n",
              "      <td>(75.725, 100.0]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>61.1</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>45.8</td>\n",
              "      <td>(27.175, 51.45]</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>54.2</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    AGE        Auto_BINS\n",
              "0  65.2  (51.45, 75.725]\n",
              "1  78.9  (75.725, 100.0]\n",
              "2  61.1  (51.45, 75.725]\n",
              "3  45.8  (27.175, 51.45]\n",
              "4  54.2  (51.45, 75.725]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HGvI3DLgHDDr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 332
        },
        "outputId": "296a4a77-e7bf-4df4-81ee-a4eb5f7dbb37"
      },
      "source": [
        "# Manual Binning\n",
        "\n",
        "# We specify in the code about where the bins are to be created.\n",
        "AgeData['Manual_BINS']=pd.cut(AgeData['AGE'],bins=[0,50,60,70,80],\n",
        "                              labels=[\"0-50\",\"51-60\",\"61-70\",\"70+\"])\n",
        "AgeData.head()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:5: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  \"\"\"\n"
          ],
          "name": "stderr"
        },
        {
          "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>AGE</th>\n",
              "      <th>Auto_BINS</th>\n",
              "      <th>Manual_BINS</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>65.2</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "      <td>61-70</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>78.9</td>\n",
              "      <td>(75.725, 100.0]</td>\n",
              "      <td>70+</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>61.1</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "      <td>61-70</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>45.8</td>\n",
              "      <td>(27.175, 51.45]</td>\n",
              "      <td>0-50</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>54.2</td>\n",
              "      <td>(51.45, 75.725]</td>\n",
              "      <td>51-60</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "    AGE        Auto_BINS Manual_BINS\n",
              "0  65.2  (51.45, 75.725]       61-70\n",
              "1  78.9  (75.725, 100.0]         70+\n",
              "2  61.1  (51.45, 75.725]       61-70\n",
              "3  45.8  (27.175, 51.45]        0-50\n",
              "4  54.2  (51.45, 75.725]       51-60"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fmkCqtOdS8lZ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "e858f659-01dd-4db9-c95b-4e2d1057dbd6"
      },
      "source": [
        "# Encoding\n",
        "\n",
        "# Encoding is a process of creating numerical variables from categorical variables\n",
        "# This is done in order to make the categorical features available for analysis \n",
        "# as most of the learning algorithms require numerical features for their functioning.\n",
        "\n",
        "# Creating Dataset\n",
        "# We create an arbitrary dataset having Age and Gender of 10 individuals.\n",
        "Encode1 = pd.DataFrame({'Gender':['M','F','F','M','M','M','F','M','F','F'],\n",
        "                       'Age':['22','23','24','26','28','30','27','32','35','37']})\n",
        "Encode1"
      ],
      "execution_count": null,
      "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>Gender</th>\n",
              "      <th>Age</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>M</td>\n",
              "      <td>22</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>F</td>\n",
              "      <td>23</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>F</td>\n",
              "      <td>24</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>M</td>\n",
              "      <td>26</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>M</td>\n",
              "      <td>28</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>M</td>\n",
              "      <td>30</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>F</td>\n",
              "      <td>27</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>M</td>\n",
              "      <td>32</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>F</td>\n",
              "      <td>35</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>F</td>\n",
              "      <td>37</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  Gender Age\n",
              "0      M  22\n",
              "1      F  23\n",
              "2      F  24\n",
              "3      M  26\n",
              "4      M  28\n",
              "5      M  30\n",
              "6      F  27\n",
              "7      M  32\n",
              "8      F  35\n",
              "9      F  37"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n_k-zvpWTntr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "96f40260-f922-4d73-c291-5d5ddfa3bbab"
      },
      "source": [
        "# get_dummies: It is one of the available functions to perform Encoding.\n",
        " \n",
        "# Performing Encoding\n",
        "Encode1_Dummy = pd.get_dummies(Encode1,columns=['Gender'])\n",
        "Encode1_Dummy"
      ],
      "execution_count": null,
      "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>Age</th>\n",
              "      <th>Gender_F</th>\n",
              "      <th>Gender_M</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>22</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>23</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>24</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>26</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>28</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>30</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>27</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>32</td>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>35</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>37</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  Age  Gender_F  Gender_M\n",
              "0  22         0         1\n",
              "1  23         1         0\n",
              "2  24         1         0\n",
              "3  26         0         1\n",
              "4  28         0         1\n",
              "5  30         0         1\n",
              "6  27         1         0\n",
              "7  32         0         1\n",
              "8  35         1         0\n",
              "9  37         1         0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IRSXGdHVUWrK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "44995ba0-1502-4dc5-a797-d0eec965996a"
      },
      "source": [
        "# Using drop_first\n",
        "\n",
        "# Most of the times, if we have x number of categorical variables \n",
        "# then we want x-1 number of dummy variables. To do so we use the drop_first command.\n",
        "\n",
        "Encode1_Dummy = pd.get_dummies(Encode1,columns=['Gender'],drop_first=True)\n",
        "Encode1_Dummy"
      ],
      "execution_count": null,
      "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>Age</th>\n",
              "      <th>Gender_M</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>22</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>23</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>24</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>26</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>28</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>30</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>27</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>32</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>35</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>37</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "  Age  Gender_M\n",
              "0  22         1\n",
              "1  23         0\n",
              "2  24         0\n",
              "3  26         1\n",
              "4  28         1\n",
              "5  30         1\n",
              "6  27         0\n",
              "7  32         1\n",
              "8  35         0\n",
              "9  37         0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ezUJTzMUvFW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "01d6055e-cd46-42b1-dbca-ff6102065914"
      },
      "source": [
        "# One Hot Encoding\n",
        "\n",
        "# It is another method of Encoding\n",
        "onehot_encoder = OneHotEncoder(sparse=False)\n",
        "print(onehot_encoder)\n",
        "label_encoder = LabelEncoder()\n",
        "print(label_encoder)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "OneHotEncoder(categories='auto', drop=None, dtype=<class 'numpy.float64'>,\n",
            "              handle_unknown='error', sparse=False)\n",
            "LabelEncoder()\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QXteOvcIe2a9",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "8e7ed0a0-be54-4f04-af63-a49aba0d34e4"
      },
      "source": [
        "# Labeling\n",
        "\n",
        "# Here Label encoder is used to first label the the column ‘Gender’ i.e. the gender to 0s and 1s.\n",
        "integer_encoded = label_encoder.fit_transform(Encode1['Gender'])\n",
        "integer_encoded"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 0, 0, 1, 1, 1, 0, 1, 0, 0])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jht2Vj2UfP_p",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "c09dcbaa-1a70-4d03-faaa-8f6ea3676644"
      },
      "source": [
        "# Performing One-Hot Encoding\n",
        "\n",
        "# After the categorical variable has been labeled to 0s and 1s, \n",
        "# we will use one hot encoding to create dummy variable for ‘Gender’\n",
        "integer_encoded = integer_encoded.reshape(len(integer_encoded), 1)\n",
        "onehot_encoded = onehot_encoder.fit_transform(integer_encoded)\n",
        "onehot_encoded"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 1.],\n",
              "       [1., 0.],\n",
              "       [1., 0.],\n",
              "       [0., 1.],\n",
              "       [0., 1.],\n",
              "       [0., 1.],\n",
              "       [1., 0.],\n",
              "       [0., 1.],\n",
              "       [1., 0.],\n",
              "       [1., 0.]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i0zUn8b8fjKB",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "outputId": "cd802e9a-b98c-47cd-ddab-4d5012d56ef8"
      },
      "source": [
        "# One_Hot Encoding on Dataset\n",
        "# We now perform One_Hot encoding on the dataset \n",
        "# that we used above during the application of the get_Dummies function.\n",
        " \n",
        "# Separate Categorical Variables and perform Labeling\n",
        "# We first separate the categorical variables from the dataset and then label them.\n",
        "Encode2 = Encode1[['Gender']]\n",
        "int_lab = Encode2.apply(label_encoder.fit_transform)\n",
        "int_lab.head()"
      ],
      "execution_count": null,
      "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>Gender</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Gender\n",
              "0       1\n",
              "1       0\n",
              "2       0\n",
              "3       1\n",
              "4       1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5q_p0o2f_Sp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "995725cb-351d-401e-8000-8f96978467c5"
      },
      "source": [
        "# Perform One-Hot Encoding on Dataset\n",
        "\n",
        "# We now perform One-Hot Encoding on these categorical labelled variables.\n",
        "Onhotencode = OneHotEncoder(sparse=False,dtype=int)\n",
        "one_hot_encode_output = Onhotencode.fit_transform(int_lab)\n",
        "one_hot_encode_output"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1],\n",
              "       [1, 0],\n",
              "       [1, 0],\n",
              "       [0, 1],\n",
              "       [0, 1],\n",
              "       [0, 1],\n",
              "       [1, 0],\n",
              "       [0, 1],\n",
              "       [1, 0],\n",
              "       [1, 0]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dNg7V5sugNO8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 359
        },
        "outputId": "f2ab934b-784f-4a79-a800-af83c904376c"
      },
      "source": [
        "# Transforming the output into Dataframe\n",
        "\n",
        "# For our convenience and ease, we transform the above output into a Dataframe.\n",
        "one_hot_encode_output1 = pd.DataFrame(one_hot_encode_output,\n",
        "                                      columns=['Gender_F','Gender_M'])\n",
        "one_hot_encode_output1"
      ],
      "execution_count": null,
      "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>Gender_F</th>\n",
              "      <th>Gender_M</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>5</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>6</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>7</th>\n",
              "      <td>0</td>\n",
              "      <td>1</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>8</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>9</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "   Gender_F  Gender_M\n",
              "0         0         1\n",
              "1         1         0\n",
              "2         1         0\n",
              "3         0         1\n",
              "4         0         1\n",
              "5         0         1\n",
              "6         1         0\n",
              "7         0         1\n",
              "8         1         0\n",
              "9         1         0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    }
  ]
}