CRISPDM_2__feature-engineering-for-machine-learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Good Links  Features engineer \n",
    "https://www.analyticsvidhya.com/blog/2020/12/feature-engineering-feature-improvements-scaling/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Why generate features?\n",
    "\n",
    "1. Why generate features?\n",
    "Hello and welcome to Feature Engineering for Machine Learning in Python. My name is Robert O’Callaghan and I am a Data Scientist.\n",
    "\n",
    "\n",
    "2. Feature Engineering\n",
    "\n",
    "Feature engineering is the act of taking raw data and extracting features from it that are suitable for tasks like machine learning. Most machine learning algorithms work with tabular data. When we talk about features, we are referring to the information stored in the columns of these tables. For example, if we were looking at information on houses, the features would be things like square foot, number of rooms, etc. This course is designed for data scientists who want to expand their knowledge of how to incorporate feature engineering into their data science workflow.\n",
    "\n",
    "3. Different types of data\n",
    "\n",
    "Most machine learning algorithms require their input data to be represented as a vector or a matrix, and many assume that the data is distributed normally. In the real world, more often than not you will receive data that is not in this format. You will also need to work with many different types of data, some data types you will often encounter are: continuous variables, categorical data, ordinal data, boolean values, and dates and times. Dealing with these is manageable, but requires a well thought out approach. Feature engineering is often overlooked in machine learning discussions, but any real-world practitioner will confirm that data manipulation and feature engineering is the most important aspect of the project.\n",
    "\n",
    "4. Course structure\n",
    "\n",
    "Over the span of this course, we will be addressing how to deal with many different types of data and how to convert them into a format that can be easily used for machine learning. In the first chapter, you will ingest and create basic features from tabular data. In the second chapter, you will learn how to deal with data that has missing values. You will then move on to transforming your data so that it conforms to statistical assumptions often necessary for machine learning models, and finally, you will convert free form text into tabular data so it can be used with machine learning models.\n",
    "\n",
    "5. Pandas\n",
    "\n",
    "Now lets jump straight in with some examples. During this course we will be leveraging the pandas package substantially as it is very useful when working with data in tabular form. It is a common practice to import pandas using the pd alias. You can use the read_csv() function to import a CSV file and use the head() method to quickly look at the first few rows of the DataFrame.\n",
    "\n",
    "6. Dataset\n",
    "\n",
    "For the first three chapters of this course, you will be working with a modified subset of the Stackoverflow survey response data. This data set records the details and preferences of hundreds of users of the StackOverflow website.\n",
    "\n",
    "7. Column names\n",
    "\n",
    "To see the features used in this subset, you can use the DataFrame columns attribute to print the names of all the columns in the DataFrame.\n",
    "\n",
    "\n",
    "8. Column types\n",
    "\n",
    "To print the data type of each column, you can use the dtypes attribute. Here you can see three different data types - integers, floats and objects - in pandas objects are columns that contain strings.\n",
    "\n",
    "9. Selecting specific data types\n",
    "\n",
    "Knowing the types of each column can be very useful if you are performing analysis based on a subset of specific data types. To do this, you can use the select_dtypes() method and pass a list of relevant data types to the include argument. For example, if you want to select only the integer columns, call the select_dtypes() method on df and set the include argument to 'int'.\n",
    "\n",
    "# Getting to know your data\n",
    "\n",
    "Pandas is one the most popular packages used to work with tabular data in Python. It is generally imported using the alias pd and can be used to load a CSV (or other delimited files) using read_csv().\n",
    "\n",
    "You will be working with a modified subset of the Stackoverflow survey response data in the first three chapters of this course. This data set records the details, and preferences of thousands of users of the StackOverflow website."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      SurveyDate                                    FormalEducation  \\\n",
      "0  2/28/18 20:20           Bachelor's degree (BA. BS. B.Eng.. etc.)   \n",
      "1  6/28/18 13:26           Bachelor's degree (BA. BS. B.Eng.. etc.)   \n",
      "2    6/6/18 3:37           Bachelor's degree (BA. BS. B.Eng.. etc.)   \n",
      "3    5/9/18 1:06  Some college/university study without earning ...   \n",
      "4  4/12/18 22:41           Bachelor's degree (BA. BS. B.Eng.. etc.)   \n",
      "\n",
      "   ConvertedSalary Hobby       Country  StackOverflowJobsRecommend  \\\n",
      "0              NaN   Yes  South Africa                         NaN   \n",
      "1          70841.0   Yes       Sweeden                         7.0   \n",
      "2              NaN    No       Sweeden                         8.0   \n",
      "3          21426.0   Yes       Sweeden                         NaN   \n",
      "4          41671.0   Yes            UK                         8.0   \n",
      "\n",
      "      VersionControl  Age  Years Experience Gender   RawSalary  \n",
      "0                Git   21                13   Male         NaN  \n",
      "1     Git;Subversion   38                 9   Male   70,841.00  \n",
      "2                Git   45                11    NaN         NaN  \n",
      "3  Zip file back-ups   46                12   Male   21,426.00  \n",
      "4                Git   39                 7   Male  £41,671.00  \n"
     ]
    }
   ],
   "source": [
    "# Import pandas\n",
    "import pandas as pd\n",
    "\n",
    "# Import so_survey_csv into so_survey_df\n",
    "#so_survey_df = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/inaugural_speeches.csv')\n",
    "so_survey_df = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/Combined_DS_v10.csv')\n",
    "# Print the first five rows of the DataFrame\n",
    "print(so_survey_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SurveyDate                     object\n",
      "FormalEducation                object\n",
      "ConvertedSalary               float64\n",
      "Hobby                          object\n",
      "Country                        object\n",
      "StackOverflowJobsRecommend    float64\n",
      "VersionControl                 object\n",
      "Age                             int64\n",
      "Years Experience                int64\n",
      "Gender                         object\n",
      "RawSalary                      object\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "# Print the data type of each column\n",
    "print(so_survey_df.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['ConvertedSalary', 'StackOverflowJobsRecommend', 'Age',\n",
      "       'Years Experience'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Create subset of only the numeric columns\n",
    "so_numeric_df = so_survey_df.select_dtypes(include=['int', 'float'])\n",
    "# Print the column names contained in so_survey_df_num\n",
    "print(so_numeric_df.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dealing with categorical features\n",
    "1. Dealing with Categorical Variables\n",
    "\n",
    "Categorical variables are used to represent groups that are qualitative in nature. Some examples are colors, such as blue, red, black etc. or country of birth, such as Ireland, England or USA. While these can easily be understood by a human, you will need to encode categorical features as numeric values to use them in your machine learning models.\n",
    "2. Encoding categorical features\n",
    "\n",
    "As an example, here is a table which consists of the country of residence of different respondents in the Stackoverflow survey. To get from qualitative inputs to quantitative features, one may naively think that assigning every category in a column a number would suffice, for example India could be 1, USA 2 etc. But these categories are unordered, so assigning this order may greatly penalize the effectiveness of your model. Thus, you cannot allocate arbitrary numbers to each category as that would imply some form of ordering in the categories.\n",
    "3. Encoding categorical features\n",
    "\n",
    "Instead, values can be encoded by creating additional binary features corresponding to whether each value was picked or not as shown in the table on the right. In doing so your model can leverage the information of what country is given, without inferring any order between the different options.\n",
    "4. Encoding categorical features\n",
    "\n",
    "There are two main approaches when representing categorical columns in this way, one hot encoding and dummy encoding. These are very similar and often confused. In fact, by default, pandas performs one-hot encoding when you use the get_dummies() function.\n",
    "5. One-hot encoding\n",
    "\n",
    "One-hot encoding converts n categories into n features as shown here. You can use the get_dummies() function to one-hot encode columns. The function takes a DataFrame and a list of categorical columns you want converted into one hot encoded columns, and returns an updated DataFrame with these columns included. Specifying a prefix with the prefix argument can improve readability like the letter C for country has been used here.\n",
    "6. Dummy encoding\n",
    "\n",
    "On the other hand, dummy encoding creates n-1 features for n categories, omitting the first category. Notice that this time there is no feature for France, the first category. In dummy encoding, the base value, France in this case, is encoded by the absence of all other countries as you can see on the last row here and its value is represented by the intercept. For dummy encoding, you can use the same get_dummies() function with an additional argument, drop_first set to True as shown here.\n",
    "7. One-hot vs. dummies\n",
    "\n",
    "Both these methods have different advantages. One-hot encoding generally creates much more explainable features, as each country will have its own weight that can be observed after training. But one must be aware that one hot encoding may create features that are entirely collinear due to the same information being represented multiple times.\n",
    "8. One-hot vs. dummies\n",
    "\n",
    "Take for example a simpler categorical column recording the sex of the survey takers. By recording a 1 for male the information of whether the person is female is already known when the male column is 0. This double representation can lead to instability in your models and dummy values would be more appropriate.\n",
    "9. Limiting your columns\n",
    "\n",
    "However, both one-hot encoding and dummy encoding may result in a huge number of columns being created if there are too many different categories in a column. In these cases, you may want to only create columns for the most common values. You can check the number of occurrences of different features in a column using the value_counts() method on a specific column.\n",
    "10. Limiting your columns\n",
    "\n",
    "Once you have your counts of occurrences, you can use it to limit what values you will include by first creating a mask of the values that occur less than n times. A mask is a list of booleans outlining which values in a column should be affected. First we find the categories that occur less than n times using the index attribute and wrap this inside the isin() method. After you create the mask, you can use it to replace these categories that occur less than n times with a value of your choice as shown here.\n",
    "11. Now you deal with categorical variables\n",
    "\n",
    "Lets put what has been learned into practice and work with some categorical variables. \n",
    "\n",
    "https://www.analyticsvidhya.com/blog/2020/03/one-hot-encoding-vs-label-encoding-using-scikit-learn/\n",
    "    \n",
    "    \n",
    "https://datascience.stackexchange.com/questions/78146/does-label-encoding-an-entire-dataset-cause-data-leakage\n",
    "    \n",
    "https://towardsdatascience.com/one-hot-encoding-multicollinearity-and-the-dummy-variable-trap-b5840be3c41a best !!!\n",
    "https://towardsdatascience.com/categorical-encoding-using-label-encoding-and-one-hot-encoder-911ef77fb5bd\n",
    "\n",
    "https://machinelearningmastery.com/how-to-one-hot-encode-sequence-data-in-python/\n",
    "\n",
    "**Best of the best :** \n",
    "\n",
    "https://machinelearningmastery.com/columntransformer-for-numerical-and-categorical-data/\n",
    "\n",
    "# One-hot encoding and dummy variables\n",
    "\n",
    "To use categorical variables in a machine learning model, you first need to represent them in a quantitative way. The two most common approaches are to one-hot encode the variables using or to use dummy variables. In this exercise, you will create both types of encoding, and compare the created column sets. We will continue using the same DataFrame from previous lesson loaded as so_survey_df and focusing on its Country column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['SurveyDate', 'FormalEducation', 'ConvertedSalary', 'Hobby',\n",
      "       'StackOverflowJobsRecommend', 'VersionControl', 'Age',\n",
      "       'Years Experience', 'Gender', 'RawSalary', 'OH_France', 'OH_India',\n",
      "       'OH_Ireland', 'OH_Russia', 'OH_South Africa', 'OH_Spain', 'OH_Sweeden',\n",
      "       'OH_UK', 'OH_USA', 'OH_Ukraine'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Convert the Country column to a one hot encoded Data Frame\n",
    "one_hot_encoded = pd.get_dummies(so_survey_df, columns=['Country'], prefix='OH')\n",
    "\n",
    "# Print the columns names\n",
    "print(one_hot_encoded.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['SurveyDate', 'FormalEducation', 'ConvertedSalary', 'Hobby',\n",
      "       'StackOverflowJobsRecommend', 'VersionControl', 'Age',\n",
      "       'Years Experience', 'Gender', 'RawSalary', 'DM_India', 'DM_Ireland',\n",
      "       'DM_Russia', 'DM_South Africa', 'DM_Spain', 'DM_Sweeden', 'DM_UK',\n",
      "       'DM_USA', 'DM_Ukraine'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# Create dummy variables for the Country column\n",
    "dummy = pd.get_dummies(so_survey_df, columns=['Country'], drop_first=True, prefix='DM')\n",
    "\n",
    "# Print the columns names\n",
    "print(dummy.columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you notice that the column for France was missing when you created dummy variables? Now you can choose to use one-hot encoding or dummy variables where appropriate\n",
    "# Dealing with uncommon categories\n",
    "\n",
    "Some features can have many different categories but a very uneven distribution of their occurrences. Take for example Data Science's favorite languages to code in, some common choices are Python, R, and Julia, but there can be individuals with bespoke choices, like FORTRAN, C etc. In these cases, you may not want to create a feature for each value, but only the more common occurrences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "South Africa    166\n",
      "USA             164\n",
      "Spain           134\n",
      "Sweeden         119\n",
      "France          115\n",
      "Russia           97\n",
      "India            95\n",
      "UK               95\n",
      "Ukraine           9\n",
      "Ireland           5\n",
      "Name: Country, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Create a series out of the Country column\n",
    "countries = so_survey_df.Country\n",
    "\n",
    "# Get the counts of each category\n",
    "country_counts = countries.value_counts()\n",
    "\n",
    "# Print the count values for each category\n",
    "print(country_counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualisation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://mlcourse.ai/articles/topic2-part2-seaborn-plotly/\n",
    "# https://www.tech-quantum.com/wp-content/uploads/2018/09/Data-Visualization-with-Seaborn-explained.html\n",
    "# https://stackoverflow.com/questions/63706303/how-to-order-x-axis-by-yearmonth-at-seaborn\n",
    "# https://seaborn.pydata.org/generated/seaborn.catplot.html\n",
    "# http://seaborn.pydata.org/tutorial/categorical.html?highlight=bar%20plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "Bad key savefig.frameon in file /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 421 ('savefig.frameon : True')\n",
      "You probably need to get an updated matplotlibrc file from\n",
      "https://github.com/matplotlib/matplotlib/blob/v3.3.2/matplotlibrc.template\n",
      "or from the matplotlib source distribution\n",
      "\n",
      "Bad key verbose.level in file /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 472 ('verbose.level  : silent      # one of silent, helpful, debug, debug-annoying')\n",
      "You probably need to get an updated matplotlibrc file from\n",
      "https://github.com/matplotlib/matplotlib/blob/v3.3.2/matplotlibrc.template\n",
      "or from the matplotlib source distribution\n",
      "\n",
      "Bad key verbose.fileo in file /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle, line 473 ('verbose.fileo  : sys.stdout  # a log filename, sys.stdout or sys.stderr')\n",
      "You probably need to get an updated matplotlibrc file from\n",
      "https://github.com/matplotlib/matplotlib/blob/v3.3.2/matplotlibrc.template\n",
      "or from the matplotlib source distribution\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The text.latex.preview rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The mathtext.fallback_to_cm rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: Support for setting the 'mathtext.fallback_to_cm' rcParam is deprecated since 3.3 and will be removed two minor releases later; use 'mathtext.fallback : 'cm' instead.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The validate_bool_maybe_none function was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The savefig.jpeg_quality rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The keymap.all_axes rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The animation.avconv_path rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "In /home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/matplotlib/mpl-data/stylelib/_classic_test.mplstyle: \n",
      "The animation.avconv_args rcparam was deprecated in Matplotlib 3.3 and will be removed two minor releases later.\n",
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  FutureWarning\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "sns.set(style=\"darkgrid\")\n",
    "sns.barplot(country_counts.index, country_counts .values, alpha=0.9)\n",
    "plt.title('Frequency Distribution of countries')\n",
    "plt.ylabel('Number of Occurrences', fontsize=12)\n",
    "plt.xlabel('Country', fontsize=12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "labels = so_survey_df['Country'].astype('category').cat.categories.tolist()\n",
    "counts = so_survey_df['Country'].value_counts()\n",
    "sizes = [counts[var_cat] for var_cat in labels]\n",
    "fig1, ax1 = plt.subplots()\n",
    "ax1.pie(sizes, labels=labels, autopct='%1.1f%%', shadow=True) #autopct is show the % on plot\n",
    "ax1.axis('equal')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    False\n",
      "1    False\n",
      "2    False\n",
      "3    False\n",
      "4    False\n",
      "Name: Country, dtype: bool\n"
     ]
    }
   ],
   "source": [
    "# Create a series out of the Country column\n",
    "countries = so_survey_df['Country']\n",
    "\n",
    "# Get the counts of each category\n",
    "country_counts = countries.value_counts()\n",
    "\n",
    "# Create a mask for only categories that occur less than 10 times\n",
    "mask = countries.isin(country_counts[country_counts<10].index)\n",
    "\n",
    "# Print the top 5 rows in the mask series\n",
    "print(mask.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Ukraine', 'Ireland'], dtype='object')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_counts[country_counts < 10].index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "South Africa    166\n",
      "USA             164\n",
      "Spain           134\n",
      "Sweeden         119\n",
      "France          115\n",
      "Russia           97\n",
      "India            95\n",
      "UK               95\n",
      "Other            14\n",
      "Name: Country, dtype: int64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\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"
     ]
    }
   ],
   "source": [
    "# Label all other categories as Other\n",
    "countries[mask] = 'Other'\n",
    "\n",
    "# Print the updated category counts\n",
    "print(countries.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Good work, now you can work with large data sets while grouping low frequency categories\n",
    "# Numeric variables\n",
    "\n",
    "1. Numeric variables\n",
    "\n",
    "As mentioned in the previous lesson, most machine learning models will require your data to be in numeric format. However, even if your raw data is all numeric, there is still a lot you can do to improve your features.\n",
    "\n",
    "2. Types of numeric features\n",
    "\n",
    "Numeric features can be used to represent a huge array of different characteristics and measurements. Pretty much anything that can be quantitatively measured can be recorded as numeric data. For example, age, the price of an item, counts, and even spatial data such as coordinates. Depending on the use case, numeric features can be treated in several different ways. We will work through a few of the considerations and possible feature engineering steps to keep in mind when dealing with numeric data.\n",
    "\n",
    "\n",
    "3. Does size matter?\n",
    "\n",
    "One of the first questions you should ask when working with numeric features is whether the magnitude of the feature is its most important trait, or just its direction. For example, if you had a dataset of restaurant health and safety ratings containing the number of times a restaurant had major violations, you might care far more about whether the restaurant had any major violations at all (as you would rather not take any chances), over whether it was a repeat offender. Looking at this toy dataset containing restaurant IDs and the number of times they had major violations, we can see that some restaurants have no major violations but many have one or more. We will be creating a new binary column representing whether or not a restaurant committed any violation.\n",
    "\n",
    "4. Binarizing numeric variables\n",
    "\n",
    "Here we first create a new column Binary_Violation and set it to zero. Then, we use the dot loc notation to find all rows where Number_of_Violations is greater than zero and set the Binary_Violation column to 1.\n",
    "\n",
    "5. Binarizing numeric variables\n",
    "\n",
    "As you can see here, all rows where Number_of_Violations is equal to 0 are also zeros in Binary_Violation. However, for all rows where Number_of_Violations is greater than zero is 1 in Binary_Violation.\n",
    "\n",
    "\n",
    "6. Binning numeric variables\n",
    "\n",
    "An extension of this is perhaps you wish to group a numeric variable into more than two bins. This is often useful for variables such as age, wage brackets, etc where exact numbers are less relevant than the general magnitude of the value. Consider the same dataset of restaurant health and safety ratings containing the number of times a restaurant has had major violations. This time we will be creating three groups, Group 1, for restaurants with no offenses, Group 2 for restaurants with one or two offenses and group 3 for all restaurants with three or more offenses. Bins are created by using the pandas' cut() function. You can define the intervals using the bins argument as shown here, which in this case is a list of 4 values. You can also pass a list of labels like so.\n",
    "\n",
    "7. Binning numeric variables\n",
    "\n",
    "Note as we want to include 0 in the first bin, we must set the leftmost edge to lower than that, so all values between negative infinity and 0 are labeled as 1, all values equal to 1 or 2 are labeled as 2, and values greater than 2 are labeled as 3.\n",
    "\n",
    "8. Lets start practicing!\n",
    "\n",
    "Now you know how to binarize and bin numeric columns, it's time for you to put this into practice.\n",
    "# Binarizing columns\n",
    "\n",
    "While numeric values can often be used without any feature engineering, there will be cases when some form of manipulation can be useful. For example on some occasions, you might not care about the magnitude of a value but only care about its direction, or if it exists at all. In these situations, you will want to binarize a column. In the so_survey_df data, you have a large number of survey respondents that are working voluntarily (without pay). You will create a new column titled Paid_Job indicating whether each person is paid (their salary is greater than zero)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Paid_Job  ConvertedSalary\n",
      "0         0              NaN\n",
      "1         1          70841.0\n",
      "2         0              NaN\n",
      "3         1          21426.0\n",
      "4         1          41671.0\n"
     ]
    }
   ],
   "source": [
    "# Create the Paid_Job column filled with zeros\n",
    "so_survey_df['Paid_Job'] = 0\n",
    "\n",
    "# Replace all the Paid_Job values where ConvertedSalary is > 0\n",
    "so_survey_df.loc[so_survey_df['ConvertedSalary'] > 0, 'Paid_Job'] = 1\n",
    "\n",
    "# Print the first five rows of the columns\n",
    "print(so_survey_df[['Paid_Job', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "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>Paid_Job</th>\n",
       "      <th>ConvertedSalary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>70841.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>21426.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>41671.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>994</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>995</th>\n",
       "      <td>1</td>\n",
       "      <td>58746.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>996</th>\n",
       "      <td>1</td>\n",
       "      <td>55000.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>997</th>\n",
       "      <td>0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>998</th>\n",
       "      <td>1</td>\n",
       "      <td>1000000.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>999 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Paid_Job  ConvertedSalary\n",
       "0           0              NaN\n",
       "1           1          70841.0\n",
       "2           0              NaN\n",
       "3           1          21426.0\n",
       "4           1          41671.0\n",
       "..        ...              ...\n",
       "994         0              NaN\n",
       "995         1          58746.0\n",
       "996         1          55000.0\n",
       "997         0              NaN\n",
       "998         1        1000000.0\n",
       "\n",
       "[999 rows x 2 columns]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np \n",
    "so_survey_df['Paid_Job'] = np.where(so_survey_df['ConvertedSalary'] > 0, 1,0)\n",
    "so_survey_df[['Paid_Job', 'ConvertedSalary']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**binarizing columns can also be useful for your target variables.**\n",
    "# Binning values\n",
    "\n",
    "For many continuous values you will care less about the exact value of a numeric column, but instead care about the bucket it falls into. This can be useful when plotting values, or simplifying your machine learning models. It is mostly used on continuous variables where accuracy is not the biggest concern e.g. age, height, wages.\n",
    "\n",
    "Bins are created using pd.cut(df['column_name'], bins) where bins can be an integer specifying the number of evenly spaced bins, or a list of bin boundaries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          equal_binned  ConvertedSalary\n",
      "0                  NaN              NaN\n",
      "1  (-2000.0, 400000.0]          70841.0\n",
      "2                  NaN              NaN\n",
      "3  (-2000.0, 400000.0]          21426.0\n",
      "4  (-2000.0, 400000.0]          41671.0\n"
     ]
    }
   ],
   "source": [
    "# Bin the continuous variable ConvertedSalary into 5 bins\n",
    "so_survey_df['equal_binned'] = pd.cut(so_survey_df['ConvertedSalary'], bins=5)\n",
    "# Print the first 5 rows of the equal_binned column\n",
    "print(so_survey_df[['equal_binned', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  boundary_binned  ConvertedSalary\n",
      "0             NaN              NaN\n",
      "1          Medium          70841.0\n",
      "2             NaN              NaN\n",
      "3             Low          21426.0\n",
      "4             Low          41671.0\n"
     ]
    }
   ],
   "source": [
    "# Import numpy\n",
    "import numpy as np\n",
    "# Specify the boundaries of the bins\n",
    "bins = [-np.inf, 10000, 50000, 100000, 150000, np.inf]\n",
    "# Bin labels\n",
    "labels = ['Very low', 'Low', 'Medium', 'High', 'Very high']\n",
    "# Bin the continuous variable ConvertedSalary using these boundaries\n",
    "so_survey_df['boundary_binned'] = pd.cut(so_survey_df['ConvertedSalary'], \n",
    "                                         bins=bins,labels=labels )\n",
    "# Print the first 5 rows of the boundary_binned column\n",
    "print(so_survey_df[['boundary_binned', 'ConvertedSalary']].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Correct, now you can bin columns with equal spacing and predefined boundaries.**\n",
    "# Why do missing values exist?\n",
    "\n",
    "1. Why do missing values exist?\n",
    "\n",
    "In the first chapter, we looked at the different types of data one may find when analyzing data. In this lesson, we will explore the concept of messy and missing values, how to find them, and once identified, how to deal with them.\n",
    "2. How gaps in data occur\n",
    "\n",
    "While in an ideal world every data set you come across would be perfectly complete and contain no gaps, unfortunately, this is rarely the case. Real world data often has noise or omissions. This can stem from many sources, for example: Data not being collected properly (paper surveys not being filled out fully). Collection and management errors (someone transcribing the data making a mistake). Data intentionally being omitted (people may want to skip the age box in an online form). Or gaps could be created due to transformations of the data (average of a field with missing data). This list is far from comprehensive.\n",
    "3. Why we care?\n",
    "\n",
    "You may wonder why are we discussing this? Does missing data even matter? Yes, it does, and it is extremely important to identify and deal with missing data. Many machine learning models cannot work with missing values, for example if you were performing linear regression, you would need a value for every row and column used in your data set. Missing data may be indicative of a problem in your data pipeline. If data is consistently missing in a certain column, you should investigate as to why this is the case. Missing data may provide information in itself. For example, if the number of children of a person is missing they may have no children.\n",
    "4. Missing value discovery\n",
    "\n",
    "You can use the info() method to have a preliminary look at how complete the data set is. Right from the get go you can see that the StackOverflowJobsRecommend, Gender, and RawSalary columns are highly underpopulated and we should examine where these missing values occur. This list output is useful but becomes limited with larger datasets that have missing values scattered all over their features.\n",
    "5. Finding missing values\n",
    "\n",
    "To find where these missing values exist, you can use the isnull() method as shown here. All cells where missing values exist are shown as True.\n",
    "6. Finding missing values\n",
    "\n",
    "You can also count the number of missing values in a specific column by chaining the isnull() and sum() methods as shown here.\n",
    "7. Finding non-missing values\n",
    "\n",
    "The inverse (or the non missing values) can also be found using the notnull() method. Here, all missing values are shown as False. Note that you can call the isnull() and notnull() methods on both the DataFrame as a whole, and on each of it's individual columns.\n",
    "8. Go ahead and find missing values!\n",
    "\n",
    "It's time for you to find missing values in the Stackoverflow data! \n",
    "# How sparse is my data?\n",
    "\n",
    "Most data sets contain missing values, often represented as NaN (Not a Number). If you are working with Pandas you can easily check how many missing values exist in each column.\n",
    "\n",
    "Let's find out how many of the developers taking the survey chose to enter their age (found in the Age column of so_survey_df) and their gender (Gender column of so_survey_df)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 999 entries, 0 to 998\n",
      "Data columns (total 2 columns):\n",
      " #   Column  Non-Null Count  Dtype \n",
      "---  ------  --------------  ----- \n",
      " 0   Age     999 non-null    int64 \n",
      " 1   Gender  693 non-null    object\n",
      "dtypes: int64(1), object(1)\n",
      "memory usage: 15.7+ KB\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Subset the DataFrame\n",
    "sub_df = so_survey_df[['Age','Gender' ]]\n",
    "\n",
    "# Print the number of non-missing values\n",
    "print(sub_df.info())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Age  Gender\n",
      "0  False   False\n",
      "1  False   False\n",
      "2  False    True\n",
      "3  False   False\n",
      "4  False   False\n",
      "5  False   False\n",
      "6  False   False\n",
      "7  False   False\n",
      "8  False   False\n",
      "9  False    True\n"
     ]
    }
   ],
   "source": [
    "# Print the locations of the missing values\n",
    "print(sub_df.head(10).isnull())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Gender\n",
      "0  True    True\n",
      "1  True    True\n",
      "2  True   False\n",
      "3  True    True\n",
      "4  True    True\n",
      "5  True    True\n",
      "6  True    True\n",
      "7  True    True\n",
      "8  True    True\n",
      "9  True   False\n"
     ]
    }
   ],
   "source": [
    "# Print the locations of the non-missing values\n",
    "print(sub_df.head(10).notnull())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**finding where the missing values exist can often be important.**\n",
    "# Dealing with missing values \n",
    "1. Dealing with missing values (I)\n",
    "\n",
    "Now that you can recognize why missing values occur and how to locate them, you need to know how they can be dealt with.\n",
    "2. Listwise deletion\n",
    "\n",
    "If you are confident that the missing values in your data set are occurring at random, (in other words not being intentionally omitted) the most effective and statistically sound approach to dealing with them is called 'complete case analysis' or listwise deletion. In this method, a record is fully excluded from your model if any of its values are missing. Take for example the dataset shown here. Although most of the information is available in the first and third rows, because values in the ConvertedSalary column are missing, these rows will be dropped.\n",
    "3. Listwise deletion in Python\n",
    "\n",
    "To implement listwise deletion using pandas, you can use the dropna() method, by setting the how argument to 'any'. This will delete all rows with at least one missing value.\n",
    "4. Listwise deletion in Python\n",
    "\n",
    "On the other hand, if you want to delete rows with missing values in only a specific column, you can use the subset argument. Pass a list of columns to this argument to specify which columns to consider when deleting rows.\n",
    "5. Issues with deletion\n",
    "\n",
    "While the preferable approach in situations where missing data occurs purely at random is listwise deletion, it does have its drawbacks. First, it deletes perfectly valid data points that share a row with a missing value. Second, if the missing values do not occur entirely at random it can negatively affect the model. Lastly, if you were to remove a feature instead of a row it can reduce the degrees of freedom of your model.\n",
    "6. Replacing with strings\n",
    "\n",
    "The most common way to deal with missing values is to simply fill these values using the fillna() method. To use the fillna() method on a specific column, you need to provide the value you want to replace the missing values with. In the case of categorical columns, it is common to replace missing values with strings like 'Other', 'Not Given' etc. To replace the missing values in place, in other words to modify the original DataFrame, you need to set the inplace argument to True.\n",
    "7. Recording missing values\n",
    "\n",
    "In situations where you believe that the absence or presence of data is more important than the values themselves, you can create a new column that records the absence of data and then drop the original column. To do this, all you need to do is call the notnull() method on a specific column. This will output a list of True/False values, thus recording the presence/absence of data. To drop columns from a DataFrame, you can use the drop() method and specify a list of column names which you want to drop as the columns argument.\n",
    "8. Practice time\n",
    "\n",
    "With this in mind you will now work through applying listwise deletion, and some alternatives for replacing missing values in categorical columns. \n",
    "# Listwise deletion\n",
    "\n",
    "The simplest way to deal with missing values in your dataset when they are occurring entirely at random is to remove those rows, also called 'listwise deletion'.\n",
    "\n",
    "Depending on the use case, you will sometimes want to remove all missing values in your data while other times you may want to only remove a particular column if too many values are missing in that column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(999, 14)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "so_survey_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(264, 14)\n"
     ]
    }
   ],
   "source": [
    "# Create a new DataFrame dropping all incomplete rows\n",
    "no_missing_values_rows = so_survey_df.dropna()\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_missing_values_rows.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(999, 8)\n"
     ]
    }
   ],
   "source": [
    "# Create a new DataFrame dropping all columns with incomplete rows\n",
    "no_missing_values_cols = so_survey_df.dropna(how='any', axis=1)\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_missing_values_cols.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(693, 14)\n"
     ]
    }
   ],
   "source": [
    "# Drop all rows where Gender is missing\n",
    "no_gender = so_survey_df.dropna(subset=['Gender'])\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_gender.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 693 entries, 0 to 996\n",
      "Data columns (total 14 columns):\n",
      " #   Column                      Non-Null Count  Dtype   \n",
      "---  ------                      --------------  -----   \n",
      " 0   SurveyDate                  693 non-null    object  \n",
      " 1   FormalEducation             693 non-null    object  \n",
      " 2   ConvertedSalary             467 non-null    float64 \n",
      " 3   Hobby                       693 non-null    object  \n",
      " 4   Country                     693 non-null    object  \n",
      " 5   StackOverflowJobsRecommend  345 non-null    float64 \n",
      " 6   VersionControl              693 non-null    object  \n",
      " 7   Age                         693 non-null    int64   \n",
      " 8   Years Experience            693 non-null    int64   \n",
      " 9   Gender                      693 non-null    object  \n",
      " 10  RawSalary                   467 non-null    object  \n",
      " 11  Paid_Job                    693 non-null    int64   \n",
      " 12  equal_binned                467 non-null    category\n",
      " 13  boundary_binned             467 non-null    category\n",
      "dtypes: category(2), float64(2), int64(3), object(7)\n",
      "memory usage: 72.2+ KB\n"
     ]
    }
   ],
   "source": [
    "no_gender.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(693, 14)\n"
     ]
    }
   ],
   "source": [
    "# Drop all rows where Gender is missing\n",
    "no_gender = so_survey_df.dropna(subset=['Gender'])\n",
    "\n",
    "# Print the shape of the new DataFrame\n",
    "print(no_gender.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see dropping all rows that contain any missing values may greatly reduce the size of your dataset. So you need to think carefully and consider several trade-offs when deleting missing values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Replacing missing values with constants\n",
    "\n",
    "While removing missing data entirely maybe a correct approach in many situations, this may result in a lot of information being omitted from your models.\n",
    "\n",
    "You may find categorical columns where the missing value is a valid piece of information in itself, such as someone refusing to answer a question in a survey. In these cases, you can fill all missing values with a new category entirely, for example 'No response given'.\n",
    "https://stackoverflow.com/questions/32617811/imputation-of-missing-values-for-categories-in-pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Male                                                                         632\n",
      "Female                                                                        53\n",
      "Transgender                                                                    2\n",
      "Female;Male                                                                    2\n",
      "Female;Male;Transgender;Non-binary. genderqueer. or gender non-conforming      1\n",
      "Male;Non-binary. genderqueer. or gender non-conforming                         1\n",
      "Non-binary. genderqueer. or gender non-conforming                              1\n",
      "Female;Transgender                                                             1\n",
      "Name: Gender, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Print the count of occurrences\n",
    "print(so_survey_df['Gender'].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Male                                                                         632\n",
      "Not Given                                                                    306\n",
      "Female                                                                        53\n",
      "Transgender                                                                    2\n",
      "Female;Male                                                                    2\n",
      "Female;Male;Transgender;Non-binary. genderqueer. or gender non-conforming      1\n",
      "Male;Non-binary. genderqueer. or gender non-conforming                         1\n",
      "Non-binary. genderqueer. or gender non-conforming                              1\n",
      "Female;Transgender                                                             1\n",
      "Name: Gender, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Replace missing values\n",
    "so_survey_df['Gender'].fillna('Not Given', inplace=True)\n",
    "\n",
    "# Print the count of each value\n",
    "print(so_survey_df['Gender'].value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**By filling in these missing values you can use the columns in your analyses.**\n",
    "https://stackoverflow.com/questions/49050974/how-fill-na-null-for-categorical-varibles-in-python-using-fillna-function\n",
    "\n",
    "1. Fill continuous missing values\n",
    "While listwise deletion is often the most statistically sound method of dealing with missing values in cases where you believe the gaps are at random, this will often not be feasible in real world use cases.\n",
    "\n",
    "2. Deleting missing values\n",
    "One of the most common issues with removing all rows with missing values is if you were building a predictive model. If you were to remove all cases that had missing values when training your model, you would quickly run into problems when you received missing values in your test set, where you do not have the option of just not predicting these rows.\n",
    "\n",
    "3. What else can you do?\n",
    "So what's the alternative? Replacing missing values. For categorical columns, as you saw in the last lesson you can either replace missing values with a string that flags missing values such as 'None', or you can use the most common occurring value. However, for numeric columns, you may want to replace missing values with a more suitable value. So what is a suitable value?\n",
    "\n",
    "4. Measures of central tendency\n",
    "In cases like this we often turn to the measures of central tendency, which are the central or typical value for a distribution. The most commonly used values are the mean and the median. One caveat that you must keep in mind when using these methods is that it can lead to biased estimates of the variances and covariances of the features. Similarly, the standard error and test statistics can be incorrectly estimated so if these metrics are needed they should be calculated before the missing values have been filled.\n",
    "\n",
    "5. Calculating the measures of central tendency\n",
    "You can calculate these measures directly from a pandas series by simply calling the required method on the series as shown here. Note that the missing values are excluded by default when calculating these statistics.\n",
    "\n",
    "6. Fill the missing values\n",
    "Then leveraging what you implemented in previous lesson, you can directly fill all missing values using the fillna() method. Only this time you are filling missing values in the ConvertedSalary column with the mean of this column. Since you filled in the missing values with the mean, you may end up with too many decimal places. You can get rid of all the decimal values by changing the data type to integer using the astype() method like so.\n",
    "\n",
    "7. Rounding values\n",
    "or you can first round the mean before filling in the missing values as shown here.\n",
    "\n",
    "8. Let's Practice!\n",
    "Now its your turn to put what you have learned into practice.\n",
    "# Filling continuous missing values\n",
    "\n",
    "In the last lesson, you dealt with different methods of removing data missing values and filling in missing values with a fixed string. These approaches are valid in many cases, particularly when dealing with categorical columns but have limited use when working with continuous values. In these cases, it may be most valid to fill the missing values in the column with a value calculated from the entries present in the column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    NaN\n",
      "1    7.0\n",
      "2    8.0\n",
      "3    NaN\n",
      "4    8.0\n",
      "Name: StackOverflowJobsRecommend, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Print the first five rows of StackOverflowJobsRecommend column\n",
    "print(so_survey_df['StackOverflowJobsRecommend'].head(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    7.061602\n",
      "1    7.000000\n",
      "2    8.000000\n",
      "3    7.061602\n",
      "4    8.000000\n",
      "Name: StackOverflowJobsRecommend, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Fill missing values with the mean\n",
    "so_survey_df['StackOverflowJobsRecommend'].fillna(so_survey_df['StackOverflowJobsRecommend'].mean(), inplace=True)\n",
    "# Print the first five rows of StackOverflowJobsRecommend column\n",
    "print(so_survey_df['StackOverflowJobsRecommend'].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    7.0\n",
      "1    7.0\n",
      "2    8.0\n",
      "3    7.0\n",
      "4    8.0\n",
      "Name: StackOverflowJobsRecommend, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Fill missing values with the mean\n",
    "so_survey_df['StackOverflowJobsRecommend'].fillna(so_survey_df['StackOverflowJobsRecommend'].mean(), inplace=True)\n",
    "\n",
    "# Round the StackOverflowJobsRecommend values\n",
    "so_survey_df['StackOverflowJobsRecommend'] = round(so_survey_df['StackOverflowJobsRecommend'])\n",
    "\n",
    "# Print the top 5 rows\n",
    "print(so_survey_df['StackOverflowJobsRecommend'].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nicely done, remember you should only round your values if you are certain it is applicable.**\n",
    "# Imputing values in predictive models\n",
    "\n",
    "When working with predictive models you will often have a separate train and test DataFrames. In these cases you want to ensure no information from your test set leaks into your train set. When filling missing values in data to be used in these situations how should approach the two data sets?\n",
    "\n",
    "#### ==>Apply the measures of central tendency (mean/median etc.) calculated on the train set to both the train and test sets.\n",
    "#### ==> values calculated on the train test should be applied to both DataFrames.\n",
    "# Dealing with other data issues\n",
    "\n",
    "1. Dealing with other data issues\n",
    "Up to this point you have used multiple approaches to creating and updating features when missing values are present in the data, but data issues are of course not limited to just this. In some instances, you will come across features that need to be updated in some other way. Take for example the case of a column containing a monetary value. If this dataset has been imported from excel it may contain characters such as currency signs or commas that prevents pandas from reading it as numeric values.\n",
    "\n",
    "2. Bad characters\n",
    "For example, lets look at the data type of the RawSalary column. It's an object, although intuitively, you know that it should be numeric. So why is that?\n",
    "\n",
    "3. Bad characters\n",
    "Let's take a quick peek at the data. Numeric columns should not contain any non-numeric characters. So you need to remove these commas.\n",
    "\n",
    "4. Dealing with bad characters\n",
    "Although you want the column to be a numeric column, it is of type object, which means you can use string methods to fix this column. In this case, we want to remove all occurrences of comma. We can easily achieve this by accessing the str accessor and using the replace() method. The first argument is the string you want to replace, which is the comma, and the second argument is the string you want to replace it with, which here is an empty string, which simply means you want to remove all the commas. However, the data type of this column is still object. Now you can convert your column to the relevant type as shown here.\n",
    "\n",
    "5. Finding other stray characters\n",
    "But what if attempting to change the data type raises an error? This may indicate that there are additional stray characters which you didn't account for. Instead of manually searching for values with other stray characters you can use the to_numeric() function from pandas along with the errors argument. If you set the errors argument to 'coerce', Pandas will convert the column to numeric, but all values that can't be converted to numeric will be changed to NaNs, that is missing values.\n",
    "\n",
    "6. Finding other stray characters\n",
    "You can now use the isna() method like you did earlier to find out which values failed to parse. So it looks like we also have dollar signs. You can again use the replace() method as before to remove the dollar signs.\n",
    "\n",
    "7. Chaining methods\n",
    "Before you get going onto trying these for yourself, it will be useful to delve a little deeper into method chaining. If you are applying different methods or in fact the same method several times on a column, instead of assigning the result back to the column after each iteration, you can simply chain the methods, that is, call one method after the other to obtain the desired result. For example, cleaning up characters, changing the data type, normalizing the values etc. can all be achieved by simply calling the methods one after the other as seen here.\n",
    "\n",
    "8. Go ahead and fix bad characters!\n",
    "Now that you know how to deal with stray characters, let's put it into practice.\n",
    "# Dealing with stray characters (I)\n",
    "\n",
    "In this exercise, you will work with the RawSalary column of so_survey_df which contains the wages of the respondents along with the currency symbols and commas, such as $42,000. When importing data from Microsoft Excel, more often that not you will come across data in this form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove the commas in the column\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace(',', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:2: FutureWarning: The default value of regex will change from True to False in a future version. In addition, single character regular expressions will*not* be treated as literal strings when regex=True.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "# Remove the dollar signs in the column\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace('$','')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Replacing/removing specific characters is a very useful skill.\n",
    "# Dealing with stray characters (II)\n",
    "\n",
    "In the last exercise, you could tell quickly based off of the df.head() call which characters were causing an issue. In many cases this will not be so apparent. There will often be values deep within a column that are preventing you from casting a column as a numeric type so that it can be used in a model or further feature engineering.\n",
    "\n",
    "One approach to finding these values is to force the column to the data type desired using pd.to_numeric(), coercing any values causing issues to NaN, Then filtering the DataFrame by just the rows containing the NaN values.\n",
    "\n",
    "Try to cast the RawSalary column as a float and it will fail as an additional character can now be found in it. Find the character and remove it so the column can be cast as a floa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0            NaN\n",
      "2            NaN\n",
      "4      £41671.00\n",
      "6            NaN\n",
      "8            NaN\n",
      "         ...    \n",
      "989          NaN\n",
      "990          NaN\n",
      "992          NaN\n",
      "994          NaN\n",
      "997          NaN\n",
      "Name: RawSalary, Length: 401, dtype: object\n"
     ]
    }
   ],
   "source": [
    "# Attempt to convert the column to numeric values\n",
    "numeric_vals = pd.to_numeric(so_survey_df['RawSalary'], errors='coerce')\n",
    "\n",
    "# Find the indexes of missing values\n",
    "idx = numeric_vals.isna()\n",
    "\n",
    "# Print the relevant rows\n",
    "print(so_survey_df['RawSalary'][idx])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       True\n",
       "1      False\n",
       "2       True\n",
       "3      False\n",
       "4       True\n",
       "       ...  \n",
       "994     True\n",
       "995    False\n",
       "996    False\n",
       "997     True\n",
       "998    False\n",
       "Name: RawSalary, Length: 999, dtype: bool"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0            NaN\n",
      "1        70841.0\n",
      "2            NaN\n",
      "3        21426.0\n",
      "4        41671.0\n",
      "         ...    \n",
      "994          NaN\n",
      "995      58746.0\n",
      "996      55000.0\n",
      "997          NaN\n",
      "998    1000000.0\n",
      "Name: RawSalary, Length: 999, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Replace the offending characters\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].str.replace('£','')\n",
    "\n",
    "# Convert the column to float\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary'].astype('float')\n",
    "\n",
    "# Print the column\n",
    "print(so_survey_df['RawSalary'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nicely done! Remember that even after removing all the relevant characters, you still need to change the type of the column to numeric if you want to plot these continuous values.\n",
    "# Method chaining\n",
    "\n",
    "When applying multiple operations on the same column (like in the previous exercises), you made the changes in several steps, assigning the results back in each step. However, when applying multiple successive operations on the same column, you can \"chain\" these operations together for clarity and ease of management. This can be achieved by calling multiple methods sequentially:\n",
    "\n",
    "# Method chaining\n",
    "    df['column'] = df['column'].method1().method2().method3()\n",
    "\n",
    "# Same as \n",
    "    df['column'] = df['column'].method1()\n",
    "\n",
    "    df['column'] = df['column'].method2()\n",
    "\n",
    "    df['column'] = df['column'].method3()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0            NaN\n",
      "1        70841.0\n",
      "2            NaN\n",
      "3        21426.0\n",
      "4        41671.0\n",
      "         ...    \n",
      "994          NaN\n",
      "995      58746.0\n",
      "996      55000.0\n",
      "997          NaN\n",
      "998    1000000.0\n",
      "Name: RawSalary, Length: 999, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Use method chaining\n",
    "so_survey_df['RawSalary'] = so_survey_df['RawSalary']\\\n",
    "                              .replace(',', '')\\\n",
    "                              .replace('$','')\\\n",
    "                              .replace('£','')\\\n",
    "                              .astype('float')\n",
    " \n",
    "# Print the RawSalary column\n",
    "print(so_survey_df['RawSalary'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom functions can be also used when method chaining using the .apply() method.*\n",
    "\n",
    "# What does your data look like? (I)\n",
    "\n",
    "Up until now you have focused on creating new features and dealing with issues in your data. Feature engineering can also be used to make the most out of the data that you already have and use it more effectively when creating machine learning models.\n",
    "Many algorithms may assume that your data is normally distributed, or at least that all your columns are on the same scale. This will often not be the case, e.g. one feature may be measured in thousands of dollars while another would be number of years. In this exercise, you will create plots to examine the distributions of some numeric columns in the so_survey_df DataFrame, stored in so_numeric_df\n",
    "1. Data distributions\n",
    "\n",
    "An important consideration before building a machine learning model is to understand what the distribution of your underlying data looks like. A lot of algorithms make assumptions about how your data is distributed or how different features interact with each other. For example almost all models besides tree based models require your features to be on the same scale. Feature engineering can be used to manipulate your data so that it can fit the assumptions of the distribution, or at least fit it as closely as possible.\n",
    "2. Distribution assumptions\n",
    "\n",
    "Almost every model besides tree based models assume that your data is normally distributed. Normal distributions follow a bell shape like shown here, the main characteristics of a normal distribution is that 68 percent of the data lies within 1 standard deviation of the mean,95% percent lies within 2 standard deviations from the mean and 99.7% fall within 3 standard deviations from the mean.\n",
    "3. Observing your data\n",
    "\n",
    "To understand the shape of your own data you can create histograms of each of the continuous features. To do so, once you have the matplotlib library loaded, along with your DataFrame, run hist() on your data frame followed by calling plt dot show to observe the graph. Here we see the first column has a fairly normal looking distribution, but the second looks quite different, with the majority of the data skewed to the lower values. This is also referred to having a long right tail.\n",
    "4. Delving deeper with box plots\n",
    "\n",
    "While histograms can be useful to show the high level distribution of the data, it does not show details such as where the middle chunk of your data sits in an easily readable fashion. For this you can use the box plot. The box plot shows the distribution of the data by calculating where the middle 50% of the data sits, this is also known as the Inter quartile range or IQR (it sits between the 1st and 3rd quartile) and marking it with the box. The whiskers extend to the minimum of 1.5 times the IQR from the edge of the box or the maximum range of the data. Any points outside this are marked as outliers. This can be useful to also see if there are points in your data set that may be unwanted outliers.\n",
    "5. Box plots in pandas\n",
    "\n",
    "To create a box plot in pandas, you can call the boxplot() method on a list of columns you wish to plot.\n",
    "6. Paring distributions\n",
    "\n",
    "One final approach to looking at the distribution of data is to examine how different features in your DataFrame interact with each other. This type of chart is called a pairplot and can be useful to see if multiple columns are correlated with each other or whether they have any association at all. To generate a pairplot, first you need to import the seaborn package and then call the pairplot() function on your DataFrame. In this example we can see that the first and last columns are somewhat related.\n",
    "7. Further details on your distributions\n",
    "\n",
    "While all these plots are very useful to get an understanding of your data's shape, you will at times want to quickly get summary statistics of your data's distribution. This can be found using the describe() method as seen here on the same dummy data set we have been using to demonstrate the plots.\n",
    "8. Let's practice!\n",
    "\n",
    "Why is this important? Now that you are capable of seeing the underlying structure of the data, in later lessons, you will remove outliers and ensure all features are on comparable scales. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a histogram\n",
    "so_numeric_df.hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a boxplot of two columns\n",
    "so_numeric_df[['Age', 'Years Experience']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a boxplot of ConvertedSalary\n",
    "so_numeric_df[['ConvertedSalary']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Great, as you can see the distrbutions of columns in a dataset can vary quite a bit.\n",
    "# What does your data look like? (II)\n",
    "\n",
    "In the previous exercise you looked at the distribution of individual columns. While this is a good start, a more detailed view of how different features interact with each other may be useful as this can impact your decision on what to transform and how."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import packages\n",
    "import matplotlib.pyplot as plt \n",
    "import seaborn as sns \n",
    "\n",
    "# Plot pairwise relationships\n",
    "sns.pairplot(so_numeric_df)\n",
    "\n",
    "# Show plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Print summary statistics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       ConvertedSalary  StackOverflowJobsRecommend         Age  \\\n",
      "count     6.650000e+02                  487.000000  999.000000   \n",
      "mean      9.256517e+04                    7.061602   36.003003   \n",
      "std       2.091344e+05                    2.621591   13.255127   \n",
      "min       0.000000e+00                    0.000000   18.000000   \n",
      "25%       2.755000e+04                    5.000000   25.000000   \n",
      "50%       5.556200e+04                    7.000000   35.000000   \n",
      "75%       8.823800e+04                   10.000000   45.000000   \n",
      "max       2.000000e+06                   10.000000   83.000000   \n",
      "\n",
      "       Years Experience  \n",
      "count        999.000000  \n",
      "mean           9.961962  \n",
      "std            4.878129  \n",
      "min            0.000000  \n",
      "25%            7.000000  \n",
      "50%           10.000000  \n",
      "75%           13.000000  \n",
      "max           27.000000  \n"
     ]
    }
   ],
   "source": [
    "print(so_numeric_df.describe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**understanding these summary statistics of a column can be very valuable when deciding what transformations are necessary.**\n",
    "\n",
    " As decision trees split along a singular point, they do not require all the columns to be on the same scale.\n",
    " # Scaling and transformations\n",
    " 1. Scaling and transformations\n",
    "\n",
    "As mentioned in the last video, most machine learning algorithms require your data to be on the same scale for them to be effective,\n",
    "2. Scaling data\n",
    "\n",
    "For example it is difficult to compare salary values (often measured in thousands) with ages as shown here. While this assumption of similar scales is necessary, it is rarely true in real world data. For this reason you need to rescale your data to ensure that it is on the same scale. There are many different approaches to doing this but we will discuss the two most commonly used approaches here, Min-Max scaling (sometimes referred to as normalization), and standardization.\n",
    "3. Min-Max scaling\n",
    "\n",
    "Min-Max scaling is when your data is scaled linearly between a minimum and maximum value, often 0 and 1, with 0 corresponding with the lowest value in the column, and 1 with the largest. As it is a linear scaling while the values will change, the distribution will not. Take for example the Age column from the stackoverflow dataset, the raw values lie between 20 and 80, approximately.\n",
    "4. Min-Max scaling\n",
    "\n",
    "While here after min-max scaling, although the distribution is the same, the values sit fully between 0 and 1.\n",
    "5. Min-Max scaling in Python\n",
    "\n",
    "To implement this on your data set, you first need to import MinMaxScaler from scikit learn's preprocessing module, scikit learn is the most commonly used machine learning library for python. You then instantiate the MinMaxScaler() and fit it to your data. This tells the scaler how it should scale values when it performs the transformation. Finally, you need to actually transform the data with this new fitted scaler. Note that as this scaler assumes the max value it is created with is your upper bound, new data from outside this range may create unforeseen results.\n",
    "6. Standardization\n",
    "\n",
    "The other commonly used scaler is called standardization. As opposed to finding an outer boundary and squeezing everything within it, standardization instead finds the mean of your data and centers your distribution around it, calculating the number of standard deviations away from the mean each point is. These values (the number of standard deviations) are then used as your new values. This centers the data around 0 but technically has no limit to the maximum and minimum values as you can see here.\n",
    "7. Standardization in Python\n",
    "\n",
    "You can apply standardization in a similar fashion to how the min-max scaler was implemented. You first import StandardScaler from scikit-learn, instantiate and then fit it on your data. Once fitted you can apply it to your data.\n",
    "8. Log Transformation\n",
    "\n",
    "Both normalization and min-max scaling are types of scalers, in other words the data remained in the same shape but was squashed or scaled. A log transformation on the other hand can be used to make highly skewed distributions less skewed. Take for example one of the salary columns from the stack overflow dataset shown here where there is a very long right tail.\n",
    "9. Log transformation in Python\n",
    "\n",
    "Although it effects your data quite differently, a log transformation is implemented in Python the same way you have implemented scalers. To use a log transform you first import PowerTransformer from sklearn's preprocessing module, then you fit it to your dataset, and once fitted you can transform your data. Log transformation is a type of power transformation, hence the name.\n",
    "10. Final Slide\n",
    "\n",
    "Now it is your turn to apply these three techniques to the data you are familiar with, and see what the transformed data looks like. \n",
    "#  Normalization\n",
    "\n",
    "As discussed in the video, in normalization you linearly scale the entire column between 0 and 1, with 0 corresponding with the lowest value in the column, and 1 with the largest.\n",
    "When using scikit-learn (the most commonly used machine learning library in Python) you can use a MinMaxScaler to apply normalization. (It is called this as it scales your values between a minimum and maximum value.)\n",
    "\n",
    "**Normalization scales all points linearly between the upper and lower bound.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Age_MM  Age\n",
      "0  0.046154   21\n",
      "1  0.307692   38\n",
      "2  0.415385   45\n",
      "3  0.430769   46\n",
      "4  0.323077   39\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:16: 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",
      "  app.launch_new_instance()\n"
     ]
    }
   ],
   "source": [
    "\"\"\" Import MinMaxScaler from sklearn's preprocessing module.\n",
    "    Instantiate the MinMaxScaler() as MM_scaler.\n",
    "    Fit the MinMaxScaler on the Age column of so_numeric_df.\n",
    "    Transform the same column with the scaler you just fit.\n",
    "\"\"\"\n",
    "# Import MinMaxScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# Instantiate MinMaxScaler\n",
    "MM_scaler = MinMaxScaler()\n",
    "\n",
    "# Fit MM_scaler to the data\n",
    "MM_scaler.fit(so_numeric_df[['Age']])\n",
    "\n",
    "# Transform the data using the fitted scaler\n",
    "so_numeric_df['Age_MM'] = MM_scaler.transform(so_numeric_df[['Age']])\n",
    "\n",
    "# Compare the origional and transformed column\n",
    "print(so_numeric_df[['Age_MM', 'Age']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<AxesSubplot:title={'center':'Age_MM'}>,\n",
       "        <AxesSubplot:title={'center':'Age'}>]], dtype=object)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "so_numeric_df[['Age_MM', 'Age']].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Did you notice that all values have been scaled between 0 and 1?**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Age_SS  Age\n",
      "0 -1.132431   21\n",
      "1  0.150734   38\n",
      "2  0.679096   45\n",
      "3  0.754576   46\n",
      "4  0.226214   39\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:11: 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",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    }
   ],
   "source": [
    "# Import StandardScaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# Instantiate StandardScaler\n",
    "SS_scaler = StandardScaler()\n",
    "# Fit SS_scaler to the data\n",
    "SS_scaler.fit(so_numeric_df[['Age']])\n",
    "# Transform the data using the fitted scaler\n",
    "so_numeric_df['Age_SS'] = SS_scaler.transform(so_numeric_df[['Age']])\n",
    "# Compare the origional and transformed column\n",
    "print(so_numeric_df[['Age_SS', 'Age']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<AxesSubplot:title={'center':'Age_SS'}>,\n",
       "        <AxesSubplot:title={'center':'Age'}>]], dtype=object)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "so_numeric_df[['Age_SS', 'Age']].hist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**you can see that the values have been scaled linearly, but not between set values.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     Age_SS  Age\n",
      "0 -1.132431   21\n",
      "1  0.150734   38\n",
      "2  0.679096   45\n",
      "3  0.754576   46\n",
      "4  0.226214   39\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:11: 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",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    }
   ],
   "source": [
    "# Import StandardScaler\n",
    "from  sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Instantiate StandardScaler\n",
    "SS_scaler = StandardScaler()\n",
    "\n",
    "# Fit SS_scaler to the data\n",
    "SS_scaler.fit(so_numeric_df[['Age']])\n",
    "\n",
    "# Transform the data using the fitted scaler\n",
    "so_numeric_df['Age_SS'] = SS_scaler.transform(so_numeric_df[['Age']])\n",
    "\n",
    "# Compare the origional and transformed column\n",
    "print(so_numeric_df[['Age_SS', 'Age']].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Log transformation\n",
    "\n",
    "In the previous exercises you scaled the data linearly, which will not affect the data's shape. This works great if your data is normally distributed (or closely normally distributed), an assumption that a lot of machine learning models make. Sometimes you will work with data that closely conforms to normality, e.g the height or weight of a population. On the other hand, many variables in the real world do not follow this pattern e.g, wages or age of a population. In this exercise you will use a log transform on the ConvertedSalary column in the so_numeric_df DataFrame as it has a large amount of its data centered around the lower values, but contains very high values also. These distributions are said to have a long right tail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:11: 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",
      "  # This is added back by InteractiveShellApp.init_path()\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Import PowerTransformer\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "\n",
    "# Instantiate PowerTransformer\n",
    "pow_trans = PowerTransformer()\n",
    "\n",
    "# Train the transform on the data\n",
    "pow_trans.fit(so_numeric_df[['ConvertedSalary']])\n",
    "\n",
    "# Apply the power transform to the data\n",
    "so_numeric_df['ConvertedSalary_LG'] = pow_trans.transform(so_numeric_df[['ConvertedSalary']])\n",
    "\n",
    "# Plot the data before and after the transformation\n",
    "so_numeric_df[['ConvertedSalary', 'ConvertedSalary_LG']].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you notice the change in the shape of the distribution? ConvertedSalary_LG column looks much more normal than the original ConvertedSalary column\n",
    "# Removing outliers\n",
    "\n",
    "1. Scaling and transformations\n",
    "\n",
    "As mentioned in the last video, most machine learning algorithms require your data to be on the same scale for them to be effective,\n",
    "\n",
    "2. Scaling data\n",
    "\n",
    "For example it is difficult to compare salary values (often measured in thousands) with ages as shown here. While this assumption of similar scales is necessary, it is rarely true in real world data. For this reason you need to rescale your data to ensure that it is on the same scale. There are many different approaches to doing this but we will discuss the two most commonly used approaches here, Min-Max scaling (sometimes referred to as normalization), and standardization.\n",
    "\n",
    "3. Min-Max scaling\n",
    "\n",
    "Min-Max scaling is when your data is scaled linearly between a minimum and maximum value, often 0 and 1, with 0 corresponding with the lowest value in the column, and 1 with the largest. As it is a linear scaling while the values will change, the distribution will not. Take for example the Age column from the stackoverflow dataset, the raw values lie between 20 and 80, approximately.\n",
    "\n",
    "\n",
    "4. Min-Max scaling\n",
    "\n",
    "While here after min-max scaling, although the distribution is the same, the values sit fully between 0 and 1.\n",
    "\n",
    "5. Min-Max scaling in Python\n",
    "\n",
    "To implement this on your data set, you first need to import MinMaxScaler from scikit learn's preprocessing module, scikit learn is the most commonly used machine learning library for python. You then instantiate the MinMaxScaler() and fit it to your data. This tells the scaler how it should scale values when it performs the transformation. Finally, you need to actually transform the data with this new fitted scaler. Note that as this scaler assumes the max value it is created with is your upper bound, new data from outside this range may create unforeseen results.\n",
    "\n",
    "6. Standardization\n",
    "\n",
    "The other commonly used scaler is called standardization. As opposed to finding an outer boundary and squeezing everything within it, standardization instead finds the mean of your data and centers your distribution around it, calculating the number of standard deviations away from the mean each point is. These values (the number of standard deviations) are then used as your new values. This centers the data around 0 but technically has no limit to the maximum and minimum values as you can see here.\n",
    "\n",
    "7. Standardization in Python\n",
    "\n",
    "You can apply standardization in a similar fashion to how the min-max scaler was implemented. You first import StandardScaler from scikit-learn, instantiate and then fit it on your data. Once fitted you can apply it to your data.\n",
    "\n",
    "8. Log Transformation\n",
    "\n",
    "Both normalization and min-max scaling are types of scalers, in other words the data remained in the same shape but was squashed or scaled. A log transformation on the other hand can be used to make highly skewed distributions less skewed. Take for example one of the salary columns from the stack overflow dataset shown here where there is a very long right tail.\n",
    "\n",
    "9. Log transformation in Python\n",
    "\n",
    "Although it effects your data quite differently, a log transformation is implemented in Python the same way you have implemented scalers. To use a log transform you first import PowerTransformer from sklearn's preprocessing module, then you fit it to your dataset, and once fitted you can transform your data. Log transformation is a type of power transformation, hence the name.\n",
    "\n",
    "10. Final Slide\n",
    "\n",
    "Now it is your turn to apply these three techniques to the data you are familiar with, and see what the transformed data looks like.\n",
    "\n",
    "# Percentage based outlier removal\n",
    "\n",
    "One way to ensure a small portion of data is not having an overly adverse effect is by removing a certain percentage of the largest and/or smallest values in the column. This can be achieved by finding the relevant quantile and trimming the data using it with a mask. This approach is particularly useful if you are concerned that the highest values in your dataset should be avoided. When using this approach, you must remember that even if there are no outliers, this will still remove the same top N percentage from the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAELCAYAAAAybErdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAb60lEQVR4nO3de3BU5eHG8Wd3IQlI0pA0CUGomabiLIxCDBariDWgXFyIY8cJRNTx0g7jjVapRGWSEC511SooiUirMlTGmabIJYttAGmrtaKoaE3XItXIdU3IhRpQgWzO7w/H/QFv7nvL4vfzF7sn57zPnj3kyb5nd4/NsixLAACcwh7tAACAvodyAAAYKAcAgIFyAAAYKAcAgIFyAAAYKAcgDG666SZVVlYGvZ2XX35Zs2bNCkEioGcoB0RcVVWVrr/+euXk5Gj8+PG644479M4770Q7VsCBAwd0wQUXqLW1NSTbO3HihB555BFNmDBBOTk5ysvL09KlS0OybSBc+kU7AL5bXnjhBa1atUoLFy7U+PHj1b9/f73++ut69dVXNXbs2GjHC1khnGrVqlWqqalRZWWl0tPTdfDgwYiUYWtrq/r14784eodXDoiYlpYWPfXUUyouLtY111yjgQMHqn///srLy9P8+fN14sQJLVmyROPHj9f48eO1ZMkSnThxQpL01ltvacKECXr++ef1k5/8ROPHj9e6deskSe+//74uv/xy+f3+wFhbt27V9OnTJUltbW1atWqVJk2apHHjxmnu3Lk6cuSIpP9/lVBZWamf/vSnuuWWWzR79mxJ0iWXXKKcnBzt2rVLkvSnP/1JU6dO1SWXXKLbb79dBw8eDIz3xhtvaMqUKcrNzVVZWZlO/eKBDz/8UJMmTVJGRoZsNpuGDRum6667LrD822w5OTmaNm2atm7d2uE+XLx4sa688kpdfPHFuv76608rmaefflr33nuv5s2bp4svvlirVq3S6NGj1dzcHPiZmpoaXXrppTp58mSPnjt891AOiJhdu3bp+PHjuvrqq9td/swzz+iDDz7Qxo0btWnTJn344YeqqKgILG9oaFBLS4tee+01LVmyRGVlZfrf//6nMWPGaMCAAdqxY0fgZ6uqqgLlsGbNGm3btk0vvviiXn/9dX3ve99TWVnZaWPv3LlTr7zyip577jm9+OKLgft27dqlnJwcbdu2Tc8++6xWrFihN998U7m5ubr//vslSU1NTbrnnnv0y1/+Ujt27NAPfvADvffee4Ftjx49WqtXr9batWu1e/dunfmNNcOHD9fatWv17rvv6u6779avf/1r1dfXt7uPLrzwQm3YsEFvv/22XC6X5s6dq+PHjweWv/rqq5oyZYreeecd3Xbbbfrxj3+sP//5z4HlmzZt0rXXXqv+/ft3/EQBkmQBEbJx40brsssu63D5xIkTrb/97W+B26+99pp11VVXWZZlWTt27LAuvPBC6+TJk4Hll156qbVr1y7LsizriSeesIqKiizLsqyWlhZr9OjR1oEDByzLsqwpU6ZY//znPwPr1dXVWSNHjrROnjxp7d+/3xoxYoS1b9++wPJv7zt1rNtvv9364x//GLjt9/utiy66yDpw4IC1fv1664Ybbggsa2trs6644orAz7e2tlovvviiVVBQYI0aNcq6/PLLrZdffrnD/TBjxgxr69atlmVZ1rp166yZM2d2+LNjx461PvroI8uyLOupp56yCgsLT1u+efNmq6CgIJDjsssusz744IMOtwd8iwlJRExycrKam5s7nAuvr6/X0KFDA7eHDh162l/QycnJp603YMAAffnll5Kk6dOna+bMmVq4cKG2bt2qkSNH6txzz5UkHTp0SHfddZfs9v9/oWy329XY2Bi4PWTIkE6zHzp0SEuXLpXb7Q7cZ1mW6urqVF9ff9r6NptNmZmZgdsOh0M33nijbrzxRn399ddat26dHnroIV100UXKzs7Whg0b9MILLwSmqb788svTpoJO9fzzz6uyslL19fWy2Ww6evToaT975uOYOHGiSkpKtH//ftXW1mrQoEG66KKLOn2sgMQJaURQTk6O4uPjtW3bNk2ZMsVYnp6erkOHDun888+XJPl8PqWnp3dr2z/60Y80dOhQvfbaa/J4PHK5XIFlQ4YM0dKlS5Wbm2usd+DAAUnf/EL/1qn//lZmZqbmzJmjGTNmGMv27t2rzz//PHDbsiz5fL52cyYkJOjGG2/UU089pf/+979KSEjQggULtHr1auXk5MjhcCg/P7/ddd955x397ne/0+rVq3X++efLbrfrkksuOW2a6szs8fHxmjp1qjZt2qRPP/20w20DZ+KcAyImMTFR9957r8rKyrRt2zZ99dVXOnnypP7+97/r0Ucf1bXXXqtnnnlGTU1NampqUnl5eeC8QXe4XC6tWbNGO3fuPK18Zs2apWXLlgX+Mm9qatK2bds63E5KSorsdrv2798fuG/mzJlatWqV9uzZI+mbk+vfzuVfeeWV2rNnj7Zs2aLW1latWbNGDQ0NgXVXr16tt956S19//bVaW1u1fv16HTt2TCNHjtRXX30lm82mlJQUSdK6desCY5zp2LFjcjgcSklJUWtrq1asWKGjR492uV/y8/O1fv16bd++vd1yA9rDKwdE1K233qrU1FRVVFRo3rx5OuecczRq1CjNmTNHo0aN0rFjxwK/wKZMmaI777yz29t2uVx64oknNGHChMAvW0m6+eabZVmWbrvtNtXX1ys1NVXTpk3TpEmT2t3OgAEDNGfOHM2aNUutra36/e9/r6uvvlrHjh3Tfffdp4MHDyoxMVGXXXaZpk6dqpSUFC1fvlxLlizRgw8+qPz8fF188cWB7SUkJMjtdmvv3r2y2WzKysrS008/reHDh0uSbrvtNs2cOVM2m03XXXfdaeueavz48ZowYYImT56sgQMH6pZbbjlt+qojubm5stvtGjVqlIYNG9bt/YnvNptlcbEf4Gx38803a/r06brhhhuiHQUxgmkl4Cz3r3/9S16vV1OnTo12FMQQppWAs9j8+fO1bds2Pfzwwxo0aFC04yCGMK0EADAwrQQAMFAOAAAD5QAAMPTpE9LNzcfU1tbzUyKpqYPU2Nj1h4P6iljLK8Ve5ljLK8VeZvKGX1eZ7XabBg8+JyRj9elyaGuzelUO364bS2ItrxR7mWMtrxR7mckbfpHKzLQSAMBAOQAADJQDAMBAOQAADF2Wg9vtVl5eni644AJ9/PHHkqTm5mb9/Oc/1+TJkzV9+nTdfffdampqCqxTW1urgoICTZ48WQUFBfrss8/C9gAAAKHXZTlMnDhRa9euDVxVS/rmgiJ33HGHqqurVVVVpeHDh+vxxx8PLC8pKVFhYaGqq6tVWFio4uLi8KQHAIRFl+UwduxY4zvjk5OTNW7cuMDtMWPG6NChQ5KkxsZGeb3ewJW4XC6XvF7vaa8sAAB9W9Cfc2hra9NLL72kvLw8Sd9c2jEjI0MOh0PSN9fPTU9Pl8/nO+0CLN2Rmtq7b5E8cdKvtLTEXq0bjBMn/Yrr7+jVutHIG6xYyxxreaXYy0ze8ItU5qDLYdGiRRo4cKBmz54dijynaWw82qsPfKSlJWr6/RtDnqcrVb/N1+HDLT1eLy0tsVfrRVOsZY61vFLsZSZv+HWV2W639fqP6jMFVQ7fXvpw5cqVstu/maHKzMxUXV2d/H6/HA6H/H6/6uvru3U5QwBA39Drt7I++eSTqqmpUXl5ueLi4gL3p6amyul0yuPxSJI8Ho+cTmePp5QAANHT5SuHxYsXa8uWLWpoaNCtt96q5ORkLVu2TCtXrlRWVpZmzpwpSRo2bJjKy8slSaWlpSoqKlJFRYWSkpLkdrvD+ygAACHVZTksWLBACxYsMO7fvXt3h+tkZ2ersrIyuGQAgKjhE9IAAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAwUA4AAAPlAAAw9It2AIRGYtIAJcRH9ulMS0vU18db1fLFVxEdF0D4dfnbxO12q7q6WgcPHlRVVZVGjBghSaqtrVVRUZGOHDmi5ORkud1uZWVldbkM4ZEQ30/T798Y8XGrfpuvloiPCiDcupxWmjhxotauXatzzz33tPtLSkpUWFio6upqFRYWqri4uFvLAAB9X5flMHbsWGVmZp52X2Njo7xer1wulyTJ5XLJ6/Wqqamp02UAgNjQq0lqn8+njIwMORwOSZLD4VB6erp8Pp8sy+pwWUpKSuiSAwDCpk+fkE5NHRTtCD2WlpYY0fX6gljJHis5TxVrmckbfpHK3KtyyMzMVF1dnfx+vxwOh/x+v+rr65WZmSnLsjpc1lONjUfV1mb1eL1oPuGHD/f89GxaWmKv1jtzG9Fw4qRfcf0dURm7J++UCsU+jrRYy0ze8Osqs91uC9kf1b0qh9TUVDmdTnk8HuXn58vj8cjpdAamjTpbhrNLXH9HVN4lJfFOKSCcuiyHxYsXa8uWLWpoaNCtt96q5ORkbd68WaWlpSoqKlJFRYWSkpLkdrsD63S2DADQ93VZDgsWLNCCBQuM+7Ozs1VZWdnuOp0tAwD0fXx9BgDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDA0OU1pIG+6sRJv9LSErv98z352c58fbxVLV98FZJtAX0V5YCYFdffoen3b4z4uFW/zVdLxEcFIotpJQCAgXIAABgoBwCAgXIAABgoBwCAIeh3K/31r3/V8uXLZVmW2tradM899+iaa65RbW2tioqKdOTIESUnJ8vtdisrKysEkfuunr618lShepslAIRCUOVgWZYeeOABrV27ViNGjNB//vMfzZo1S5MmTVJJSYkKCwuVn5+vjRs3qri4WGvWrAlV7j4pWm+tlL55eyUAhErQ00p2u10tLd+867ulpUXp6elqbm6W1+uVy+WSJLlcLnm9XjU1NQU7HAAgAoJ65WCz2bRs2TLdeeedGjhwoI4dO6Znn31WPp9PGRkZcjgckiSHw6H09HT5fD6lpKR0e/upqYOCiQeETaSmAWNtupG84RepzEGVQ2trq5599llVVFQoNzdX7777rn71q1/p0UcfDUm4xsajamuzerxeLD7hiC2HD4f/M9JpaYkRGSdUyBt+XWW2220h+6M6qGmljz76SPX19crNzZUk5ebmasCAAYqPj1ddXZ38fr8kye/3q76+XpmZmcEnBgCEXVDlMGTIEH3++ef69NNPJUmffPKJGhoadN5558npdMrj8UiSPB6PnE5nj6aUAADRE9S0UlpamkpLSzV37lzZbDZJ0m9+8xslJyertLRURUVFqqioUFJSktxud0gCAwDCL+jPOcyYMUMzZsww7s/OzlZlZWWwmwcARAGfkAYAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGPoFu4Hjx49r6dKlevPNNxUfH68xY8Zo0aJFqq2tVVFRkY4cOaLk5GS53W5lZWWFIDIAINyCLofHHntM8fHxqq6uls1mU0NDgySppKREhYWFys/P18aNG1VcXKw1a9YEHRgAEH5BTSsdO3ZMGzZs0Ny5c2Wz2SRJ3//+99XY2Civ1yuXyyVJcrlc8nq9ampqCj4xACDsgnrlsH//fiUnJ2vFihV66623dM4552ju3LlKSEhQRkaGHA6HJMnhcCg9PV0+n08pKSkhCQ4ACJ+gyqG1tVX79+/XyJEjNX/+fH3wwQeaM2eOli9fHpJwqamDQrIdINTS0hLPqnFChbzhF6nMQZXD0KFD1a9fv8D00ejRozV48GAlJCSorq5Ofr9fDodDfr9f9fX1yszM7NH2GxuPqq3N6nGuWHzCEVsOH24J+xhpaYkRGSdUyBt+XWW2220h+6M6qHMOKSkpGjdunN544w1JUm1trRobG5WVlSWn0ymPxyNJ8ng8cjqdTCkBQIwI+t1KCxcu1EMPPSS3261+/frp0UcfVVJSkkpLS1VUVKSKigolJSXJ7XaHIi8AIAKCLofhw4frD3/4g3F/dna2Kisrg908ACAK+IQ0AMBAOQAADJQDAMBAOQAADJQDAMBAOQAADJQDAMBAOQAADJQDAMBAOQAADJQDAMBAOQAADJQDAMBAOQAADEF/ZTfwXXPipD9qlwn9+nirWr74KiJj47uNcgB6KK6/Q9Pv3xiVsat+m6/YurAlYhXTSgAAA+UAADBQDgAAA+UAADBQDgAAA+UAADBQDgAAA+UAADBQDgAAA+UAADCErBxWrFihCy64QB9//LEkqba2VgUFBZo8ebIKCgr02WefhWooAECYhaQc/v3vf+v999/X0KFDA/eVlJSosLBQ1dXVKiwsVHFxcSiGAgBEQNDlcOLECZWVlamkpEQ2m02S1NjYKK/XK5fLJUlyuVzyer1qamoKdjgAQAQE/a2sy5cv14wZMzR8+PDAfT6fTxkZGXI4HJIkh8Oh9PR0+Xw+paSkdHvbqamDgo0HnHUi9XXhvdGXs7Un1vJKkcscVDns2rVLH374oebNmxeqPKdpbDyqtjarx+vF4hMOdNfhw33zS7vT0hL7bLb2xFpeqevMdrstZH9UBzWttHPnTn366aeaOHGi8vLy9Pnnn+v222/Xvn37VFdXJ7/fL0ny+/2qr69XZmZmSEIDAMIrqHL4xS9+oX/84x/avn27tm/friFDhui5557TtGnT5HQ65fF4JEkej0dOp7NHU0oAgOgJ25XgSktLVVRUpIqKCiUlJcntdodrKABAiIW0HLZv3x74d3Z2tiorK0O5eQBRkpg0QAnxXf+6CPX5Pq6ZHT1cQxpAlxLi+0XlutlcMzt6+PoMAICBcgAAGCgHAICBcgAAGCgHAICBcgAAGCgHAICBzzkAMeTEST9fLImIoByAGBLX3xG1D6Phu4VpJQCAgXIAABgoBwCAgXIAABgoBwCAgXIAABgoBwCAgXIAABgoBwCAgXIAABgoBwCAgXIAABgoBwCAgXIAABgoBwCAIajrOTQ3N+uBBx7Qvn37FBcXp/POO09lZWVKSUlRbW2tioqKdOTIESUnJ8vtdisrKytEsQEA4RTUKwebzaY77rhD1dXVqqqq0vDhw/X4449LkkpKSlRYWKjq6moVFhaquLg4JIEBAOEXVDkkJydr3LhxgdtjxozRoUOH1NjYKK/XK5fLJUlyuVzyer1qamoKLi0AICJCds6hra1NL730kvLy8uTz+ZSRkSGHwyFJcjgcSk9Pl8/nC9VwAIAwCtk1pBctWqSBAwdq9uzZ8nq9IdlmauqgkGwHQOxKS0uMyW2HS6Qyh6Qc3G639u7dq5UrV8putyszM1N1dXXy+/1yOBzy+/2qr69XZmZmj7bb2HhUbW1Wj/PE4hMOoH2HD7eEZbtpaYlh23a4dJXZbreF7I/qoKeVnnzySdXU1Ki8vFxxcXGSpNTUVDmdTnk8HkmSx+OR0+lUSkpKsMMBACIgqFcOe/bs0cqVK5WVlaWZM2dKkoYNG6by8nKVlpaqqKhIFRUVSkpKktvtDklgAED4BVUO559/vnbv3t3usuzsbFVWVgazeQBAlITshDQAhNqJk/6onZD++nirWr74Kmxj93WUA4A+K66/Q9Pv3xiVsat+m6/YOl0dWny3EgDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDAwJXgAKAd4b5EaUf6yuVJKQcAaEe0LlHaVy5PyrQSAMBAOQAADJQDAMBAOQAADJQDAMAQ1nKora1VQUGBJk+erIKCAn322WfhHA4AECJhLYeSkhIVFhaqurpahYWFKi4uDudwAIAQCdvnHBobG+X1evXCCy9IklwulxYtWqSmpialpKR0axt2u63X46cPHtDrdYMRrXGjOTaP+bsx9ndt3GiO3dnvvt4u6ymbZVlWyLZ2ipqaGs2fP1+bN28O3Ddt2jQ99thjGjVqVDiGBACECCekAQCGsJVDZmam6urq5Pf7JUl+v1/19fXKzMwM15AAgBAJWzmkpqbK6XTK4/FIkjwej5xOZ7fPNwAAoids5xwk6ZNPPlFRUZG++OILJSUlye1264c//GG4hgMAhEhYywEAEJs4IQ0AMFAOAAAD5QAAMFAOAADDWXWZ0NraWhUVFenIkSNKTk6W2+1WVlZW2Mdtbm7WAw88oH379ikuLk7nnXeeysrKlJKSory8PMXFxSk+Pl6SNG/ePF1xxRVd5u3tsu7qKFc4MgWb98CBA7rrrrsCt1taWnT06FG9/fbbfWr/ut1uVVdX6+DBg6qqqtKIESPCliMU+dvL29mxLHV83ERqf3e0jyOdK5h93Nnx3Bf2cYB1FrnpppusDRs2WJZlWRs2bLBuuummiIzb3Nxs7dixI3D7kUcesR588EHLsizrqquusnbv3t3uep3l7e2y7uooVzgyhfp5Wbx4sbVw4cJOH0c08u7cudM6dOiQkSnS+7S7+dvL29mxbFnR398d7eNI5wpmH5/p1OM5Go+lI2dNOTQ0NFi5ublWa2urZVmW1draauXm5lqNjY0Rz/KXv/zFuuWWWyzL6viJ7ixvb5f1RHu5wpEp1M/L8ePHrXHjxlk1NTUdPo5wPZbuOjVTpPdpb/J39svo1GO5s5+N9P7ubjn09X185vEc6cfSmbNmWsnn8ykjI0MOh0OS5HA4lJ6eLp/PF9FPZbe1temll15SXl5e4L558+bJsizl5ubqvvvuU1JSUqd5Lcvq1bKePs4zc4UjUyjzStL27duVkZFx2pc39tX9K3V+XIZjn4Yyf3vHcl/e35HKFcrM7R3PfWUfc0I6xBYtWqSBAwdq9uzZkqS1a9dq06ZNWrdunSzLUllZWZQTfqOv5urKunXr9LOf/SxwO1YfRyw481iW+u7+7qu5unLm8Sz1ncdy1pRDX/iiP7fbrb1792rZsmWy2+2BXJIUFxenwsJCvffee13m7e2ynmgvVzgyhfJ5qaur086dOzV9+vROH0df2L+n5ovkPg1V/vaO5W8fj9T39nckc4Uqc3vHc6QfS2fOmnKI9hf9Pfnkk6qpqVF5ebni4uIkSV9++aVaWlokSZZl6ZVXXpHT6ewyb2+XdVdHucKRKZTPy/r163XllVdq8ODBfXr/nirS+zQU+ds7lvvy/o50rlAdI2cez31tH59V360UrS/627Nnj1wul7KyspSQkCBJGjZsmIqKinTPPffI7/erra1N2dnZWrBggdLT07vM29tl3bF///4Oc4UjU6iel8mTJ+vhhx/WhAkTunwc0ci7ePFibdmyRQ0NDRo8eLCSk5O1efPmiO/T7uZvL++yZcvaPZbLy8v7xP5uL/PKlSsjniuYffztBdDOPJ6lvnVMn1XlAAAIjbNmWgkAEDqUAwDAQDkAAAyUAwDAQDkAAAyUAwDAQDkAAAyUAwDA8H8jt7cyME7lhAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Find the 95th quantile of the ConvertedSalary column.\n",
    "    Trim the so_numeric_df DataFrame to retain all rows where ConvertedSalary is less than it's 95th quantile.\n",
    "    Plot the histogram of so_numeric_df[['ConvertedSalary']].\n",
    "    Plot the histogram of trimmed_df[['ConvertedSalary']].\n",
    "\"\"\"\n",
    "# Find the 95th quantile\n",
    "quantile = so_numeric_df['ConvertedSalary'].quantile(0.95)\n",
    "\n",
    "# Trim the outliers\n",
    "trimmed_df = so_numeric_df[so_numeric_df['ConvertedSalary'] < quantile  ]\n",
    "\n",
    "# The original histogram\n",
    "so_numeric_df[['ConvertedSalary']].hist()\n",
    "plt.show()\n",
    "plt.clf()\n",
    "\n",
    "# The trimmed histogram\n",
    "trimmed_df[['ConvertedSalary']].hist()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next exercise, you will work with a more statistically sound approach in removing outliers.\n",
    "# Statistical outlier removal\n",
    "\n",
    "While removing the top N% of your data is useful for ensuring that very spurious points are removed, it does have the disadvantage of always removing the same proportion of points, even if the data is correct. A commonly used alternative approach is to remove data that sits further than three standard deviations from the mean. You can implement this by first calculating the mean and standard deviation of the relevant column to find upper and lower bounds, and applying these bounds as a mask to the DataFrame. This method ensures that only data that is genuinely different from the rest is removed, and will remove fewer points if the data is close together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX8AAAEGCAYAAACNaZVuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAAAi8UlEQVR4nO3de1RU573/8TczjHctoIMO0UTNKoQ2uNRFtRYvqaCYBAWlXk685GhLoyYiNhdQV1TU2mA8VkO0PW1/aWoa05SKGi41hGalCE2JsVYTRSQuL5GbF0I0pgIO+/dHTuaUgwKjyMw4n9c/zuz9zN7fMebD5tnPfh4fwzAMRETEq5hcXYCIiHQ8hb+IiBdS+IuIeCGFv4iIF1L4i4h4IYW/iIgX8pjwT0tLY/z48YSEhHDixIk2faa2tpaf/OQnREdH8+ijj/Lyyy/f4SpFRDyDr6sLaKvIyEjmzZvH7Nmz2/yZlJQUvvvd77J582YALl68eKfKExHxKB4T/uHh4TfcfvjwYTZt2sTVq1cBSExM5KGHHuL06dOcOHGCX/ziF462ffr06ZBaRUTcnceE/41cvnyZ1atX86tf/YrAwEDOnz/PD37wA7Kzs/nkk0/o27cvK1eupKSkhD59+vDcc8/xzW9+09Vli4i4nEeH/6FDhzh37hwJCQmObT4+Ppw5cwa73c7hw4d5+umnCQ8PJy8vj0WLFpGfn+/CikVE3INHh79hGISEhPD666/fcL/NZnN0F02cOJFnn32WmpoaAgICOrJMERG34zGjfW5k2LBhnDlzhr///e+ObUeOHMEwDB588EG6detGWVkZAAcOHOAb3/gG/v7+ripXRMRt+HjKrJ7r168nLy+Pixcv4u/vj5+fHzk5ORw5coQXX3yRzz//nIaGBgYMGMAvf/lLTCYTH330EampqdTX19O1a1dWrlzJkCFDXP1VRERczmPCX0RE2o9Hd/uIiMitUfiLiHghhb+IiBfymKGen312lcZG3Z4Q99K7dw8uXfrC1WWINGMy+eDv3/2m+z0m/BsbDYW/uCX9uxRPpG4fEREvpPAXEfFCCn8RES/Uavh/9tlnJCQkEB0dzeTJk3nqqaeoqalp1s5ut5OamkpUVBQTJkwgIyOjTftERKTjtRr+Pj4+/OhHP+Ltt98mKyuLAQMGsGnTpmbtsrKyOHv2LHl5ebz55pukp6dz7ty5VveJeKKhQ0MJDOyFj48PgYG9GDo01NUliTil1fD38/Nj5MiRjvdDhw6loqKiWbvc3FymT5+OyWQiICCAqKgo9u3b1+o+EU8zdGgoFRXlhIePoKKi4n/+LNcPAPEoTvX5NzY28sYbbzB+/Phm+yorKwkKCnK8t9lsVFVVtbpPxNN8Hfy5ufnYbDZyc/MdPwBEPIVT4/zXrVtHt27dmDNnzp2q56Z69+7R4ecUuZm33tqD1doTAKu1J2+9tYegoCDHNhF31+bwT0tL48yZM47pkv8vm81GRUWFY8rkf7/ab2lfW1269IUephG3MWVKHLm5+VitPblw4QpTpsQBcOHCFdcWJvI/TCafFi+a29Tt8/Of/5yPP/6Ybdu20alTpxu2mTRpEhkZGTQ2NlJTU0N+fj7R0dGt7hPxNEFB9/Dhhx/wyCNRVFZW8sgjUXz44QcEBd3j6tJE2qzV+fzLysqIiYlh4MCBdOnSBYD+/fuzbds2EhISSExMJCwsDLvdztq1aykqKgIgISGBmTNnArS4r6105S/u5Oubvl8LCrqHf/6zxIUViTTV2pW/xyzmovAXd/R1t4+Iu2mXbh8REbm7KPxFRLyQwl9ExAsp/EVEvJDCX0TECyn8RUS8kMJfRMQLKfxFRLyQwl9ExAsp/EVEvJDCX0TECyn8RUS8kMJfRMQLKfxFRLyQwl9ExAsp/EVEvFCra/impaXx9ttvU15eTlZWFsHBwc3aPPfcc5SWljrel5aWsm3bNiIjI0lPT2fnzp0EBgYCMHz4cFavXt2OX0FERJzVavhHRkYyb948Zs+efdM2GzdudLw+fvw4jz/+OGPGjHFsi4uLIzk5+TZLFRGR9tJq+IeHhzt1wD/96U9Mnjz5pgu9i4iI67Ua/s6or68nKyuLV199tcn2nJwcCgsLsVqtLFmyhGHDhjl97JbWohRxJau1p6tLEHFau4Z/fn4+QUFBhIaGOrbNmjWLhQsXYrFYKCoqYvHixeTm5uLv7+/UsbWAu7gjLeAu7qpDF3DftWsX8fHxTbZZrVYsFgsAERER2Gw2ysrK2vO0IiLipHYL/6qqKg4ePEhMTEyT7dXV1Y7XJSUllJeXM2jQoPY6rYiI3IJWu33Wr19PXl4eFy9eZP78+fj5+ZGTk0NCQgKJiYmEhYUBsHv3br7//e/j5+fX5PObN2/m6NGjmEwmLBYLGzduxGq13pEvIyIibeNjGIZHdKSrz1/ckfr8xV11aJ+/iIh4BoW/iIgXUviLiHghhb+IiBdS+IuIeCGFv4iIF1L4i4h4IYW/iIgXUviLiHghhb+IiBdS+IuIeCGFv4iIF1L4i4h4IYW/iIgXUviLiHghhb+IiBdqNfzT0tIYP348ISEhnDhx4oZt0tPTGTVqFLGxscTGxpKamurYZ7fbSU1NJSoqigkTJpCRkdF+1YuIyC1pdRnHyMhI5s2bx+zZs1tsFxcXR3JycrPtWVlZnD17lry8PGpra4mLi2PUqFH079//1qsWEZHb0uqVf3h4ODab7ZZPkJuby/Tp0zGZTAQEBBAVFcW+fftu+XgiInL7Wr3yb6ucnBwKCwuxWq0sWbKEYcOGAVBZWUlQUJCjnc1mo6qqyunjt7QWpYgrWa09XV2CiNPaJfxnzZrFwoULsVgsFBUVsXjxYnJzc/H392+PwwNawF3ckxZwF3fVIQu4W61WLBYLABEREdhsNsrKyoCvrvQrKiocbSsrK+nXr197nFZERG5Ru4R/dXW143VJSQnl5eUMGjQIgEmTJpGRkUFjYyM1NTXk5+cTHR3dHqcVEZFb1Gq3z/r168nLy+PixYvMnz8fPz8/cnJySEhIIDExkbCwMDZv3szRo0cxmUxYLBY2btyI1WoFIDY2lsOHDzNx4kQAnnzySQYMGHBnv5WIiLTIxzAMj+hIV5+/uCP1+Yu76pA+fxER8SwKfxERL6TwFxHxQgp/EREvpPAXEfFCCn8RES+k8BcR8UIKfxERL6TwFxHxQgp/EREvpPAXEfFCCn8RES+k8BcR8UIKfxERL6TwFxHxQq0u5pKWlsbbb79NeXk5WVlZBAcHN2uzbds2cnNzMZvN+Pr6smzZMsaMGQNAeno6O3fuJDAwEIDhw4ezevXqdv4aIiLijFbDPzIyknnz5jF79uybthkyZAgLFiyga9euHD9+nDlz5lBYWEiXLl0AiIuLIzk5uf2qFhGR29Jq+IeHh7d6kK+v8gFCQkIwDIPa2lot1C4i4qbavc9/z5493HvvvU2CPycnh8mTJ7NgwQIOHTrU3qcUEREntXrl74wPPviArVu38sorrzi2zZo1i4ULF2KxWCgqKmLx4sXk5ubi7+/v1LFbWotSxJWs1p6uLkHEae0W/ocOHeLZZ59l+/btDB482LHdarU6XkdERGCz2SgrK2PEiBFOHV8LuIs70gLu4q46ZAH3I0eOsGzZMl566SW+/e1vN9lXXV3teF1SUkJ5eTmDBg1qj9OKiMgt8jEMo8XL6fXr15OXl8fFixfx9/fHz8+PnJwcEhISSExMJCwsjPj4eMrLy+nbt6/jcxs3biQkJITk5GSOHj2KyWTCYrGQmJjIuHHjnC5UV/7ijnTlL+6qtSv/VsPfXSj8xR0p/MVddUi3j4iIeBaFv4iIF1L4i4h4IYW/yC3IzMxg7NiRmM1mxo4dSWZmhqtLEnFKuz7kJeINMjMz2LBhHVu2vExMzESys/NISnoKgGnTpru4OpG20WgfESeNHTuSDRteZPTosY7RPoWFBaxY8SwFBcWuLk8E0FBPkXbXr58fn356AYvF4gj/hoYGBgywUlVV6+ryRAAN9RRpd8HBIRQXv99kW3Hx+wQHh7ioIhHnKfxFnJSU9AxJSU9RWFhAQ0MDhYUFJCU9RVLSM64uTaTNdMNXxEnTpk3nwIFiZs2Kp76+jk6dOjN37uO62SseRVf+Ik7KzMzgnXfy+MMfdlFfX88f/rCLd97J03BP8Si64SviJI32EU+g0T4i7UyjfcQTaLSPSDvTaB+5Gyj8RZyk0T5yN1C3j8gtyMzMYMuWTZw4UUpwcAhJSc9otI+4ldvu809LS+Ptt9+mvLycrKwsgoODm7Wx2+2sX7+e/fv34+Pjw49//GOmT5/e6j5nKPzFHWkxF3FXt93nHxkZyeuvv84999xz0zZZWVmcPXuWvLw83nzzTdLT0zl37lyr+0Q81bhx3yUwsBc+Pj4EBvZi3LjvurokEae0Gv7h4eHYbLYW2+Tm5jJ9+nRMJhMBAQFERUWxb9++VveJeKJx475LSckxoqMf5sKFC0RHP0xJyTH9ABCP0i43fCsrKwkKCnK8t9lsVFVVtbpPxBN9HfyvvfYmffr04bXX3nT8ABDxFB4zvUNLfVciHe33v99Bnz49ga/6/X//+x1YrVas1p4urkykbdol/G02GxUVFQwZMgRoerXf0j5n6IavuJPIyCjq6+sdo306deoEoJu/4jY65CGvSZMmkZGRQWNjIzU1NeTn5xMdHd3qPhFPFBR0D0eOHKZHj56cO3eOHj16cuTIYYKCbj4oQsTdtHrlv379evLy8rh48SLz58/Hz8+PnJwcEhISSExMJCwsjNjYWA4fPszEiRMBePLJJxkwYABAi/tEPFGvXr3w9fXlww8/cPwWe++999GtWzcXVybSdnrIS8RJmttHPEFr3T4ec8NXxF0EB4ewadML/PnP2Y4+/4cfjtHcPuJRNLePiJMiIsawdet/cenSJRobG7l06RJbt/4XERFjXF2aSJsp/EWc9Oc/Z9OjRw+6dOmCyWSiS5cu9OjRgz//OdvVpYm0mcJfxEkVFRX85jc7OHjwY+x2OwcPfsxvfrODiooKV5cm0mYKfxERL6TwF3FSUFAQS5Y80WQ+/yVLnrilhxdFXEXhL+KkVavWcf26naVLF9OlSxeWLl3M9et2Vq1a5+rSRNpMQz1FnPT1oi1btmwCoHv37qxcuVqLuYhH0UNeIrdBi7mIu9IC7iIi0ozCX0TECyn8RUS8kMJfRMQLKfxFRLyQwl9ExAsp/EVEvFCbHvI6deoUKSkp1NbW4ufnR1paGgMHDmzS5rnnnqO0tNTxvrS0lG3bthEZGUl6ejo7d+4kMDAQgOHDh7N69er2+xYiIuKUNj3kNW/ePOLj44mNjWXv3r3s2rWLHTt23LT98ePHefzxx9m/fz+dOnUiPT2dL7/8kuTk5FsuVA95iTvSQ17irm77Ia9Lly5x7NgxYmJiAIiJieHYsWPU1NTc9DN/+tOfmDx5Mp06dbqFkkVE5E5rtdunsrKSvn37YjabATCbzQQGBlJZWUlAQECz9vX19WRlZfHqq6822Z6Tk0NhYSFWq5UlS5YwbNgwpwpt6SeYSEd74403+OlPf0pJSQmhoaGsXLmS//iP/3B1WSJt1u4Tu+Xn5xMUFERoaKhj26xZs1i4cCEWi4WioiIWL15Mbm4u/v7+bT6uun3EXWRmZrBhwzq2bHmZmJiJZGfnkZT0FJcv/0uTu4nbuO1uH5vNRnV1NXa7HQC73c758+ex2Ww3bL9r1y7i4+ObbLNarVgsFgAiIiKw2WyUlZW1+UuIuJMtWzaxZcvLjB49FovFwujRY9my5WXHLJ8inqDV8O/duzehoaFkZ3+1Pml2djahoaE37PKpqqri4MGDjvsDX6uurna8Likpoby8nEGDBt1u7SIuceJEKSNHjmqybeTIUZw4UXqTT4i4nzZ1+6xZs4aUlBS2b99Or169SEtLAyAhIYHExETCwsIA2L17N9///vfx8/Nr8vnNmzdz9OhRTCYTFouFjRs3YrVa2/ebiHSQ4OAQiovfZ/TosY5txcXvExwc4sKqRJyj+fxFnHSzPv8VK55Xn7+4jdb6/BX+IrcgMzODLVs2ceJEKcHBISQlPaPgF7ei8Be5g/SQl7grreQlIiLNKPxFRLyQwl/kFmRmZjB27EjMZjNjx44kMzPD1SWJOKXdn/AVudvdbLQPoJu+4jF0w1fESWPHjmTDhhcZPXqs44ZvYWEBK1Y8S0FBsavLEwF0w1ek3Z04UUplZXmTbp/KynI94SseRVf+Ik4aOvQBrl+388tf/j9Ht8/ChT/E19fMP/953NXliQC68he5I3x8Wn4v4u4U/iJOqqqqYtWqdaxY8SxdunRhxYpnWbVqHVVVVa4uTaTNFP4iTgoODsFmC6KgoBi73U5BQTE2W5AmdhOPovAXcVJS0jMkJT1FYWEBDQ0NFBYWkJT0FElJz7i6NJE20w1fkVugid3E3WliN5E7SBO7ibtql9E+p06dYubMmURHRzNz5kxOnz7drE16ejqjRo0iNjaW2NhYUlNTHfvsdjupqalERUUxYcIEMjL0KLx4Nk3vIJ6uTdM7rF69mscee4zY2Fj27t3LqlWr2LFjR7N2cXFxJCcnN9uelZXF2bNnycvLo7a2lri4OEaNGkX//v1v/xuIdLDMzAxWrkymW7duAFy9epWVK7/6d6+uH/EUrV75X7p0iWPHjjnW5Y2JieHYsWPU1NS0+SS5ublMnz4dk8lEQEAAUVFR7Nu379arFnGhtWufx9fXzNat27l27Rpbt27H19fM2rXPu7o0kTZrNfwrKyvp27cvZrMZALPZTGBgIJWVlc3a5uTkMHnyZBYsWMChQ4eaHCMoKMjx3mazaUy0eKyKigrS0/+b0aPHYrFYGD16LOnp/01FRYWrSxNps3ab1XPWrFksXLgQi8VCUVERixcvJjc3F39//3Y5fks3LkQ6mp9fN6zWnsBXN339/Lo5Xot4glbD32azUV1djd1ux2w2Y7fbOX/+PDabrUk7q9XqeB0REYHNZqOsrIwRI0Zgs9moqKhgyJAhQPPfBNpCo33EXQQFBTFnztxmc/sEBQVp5I+4jdse7dO7d29CQ0PJzs4GIDs7m9DQUAICApq0q66udrwuKSmhvLycQYMGATBp0iQyMjJobGykpqaG/Px8oqOjb+kLibjaqlXraGy0s3TpYjp37szSpYtpbLSzatU6V5cm0mZtGud/8uRJUlJSuHz5Mr169SItLY3BgweTkJBAYmIiYWFhJCcnc/ToUUwmExaLhcTERMaNGwd8NdRz7dq1FBUVAZCQkMDMmTOdKlRX/uJOli9/htde+x319XV06tSZuXMf52c/2+TqskQc9JCXSDu72UpeK1Y8r6Ge4jYU/iLtTCt5iSdQ+Iu0s379/Pj00wtYLBZH+Dc0NDBggJWqqlpXlycCaDEXkXYXHBxCcfH7TbYVF7+vKZ3Foyj8RZykKZ3lbqBuH5FboCmdxd2pz1/kDtKUzuKu1OcvIiLNKPxFRLyQwl9ExAsp/EVEvJDCX0TECyn8RUS8kMJf5BZoAXfxdO22kpeIt7jZrJ6gBdzFc+ghLxEnjR07kkGD7ucvf3nHMZ9/ZOQETp06qVk9xW3oIS+Rdnb8eAl5eftYuXI1V69eZeXK1eTl7eP48RJXlybSZm3q9jl16hQpKSnU1tbi5+dHWloaAwcObNJm27Zt5ObmYjab8fX1ZdmyZYwZMwaA9PR0du7cSWBgIADDhw9n9erV7ftNRDqIj48Pc+c+zqJFT9GtWzcWLXqKU6dO8rvfveLq0kTarE3dPvPmzSM+Pp7Y2Fj27t3Lrl272LFjR5M2+/fvJzw8nK5du3L8+HHmzJlDYWEhXbp0IT09nS+//JLk5ORbLlTdPuIuAgN7ERDQm+7du3Pu3Kf07z+Aq1evUlNzifPnL7u6PBGgHbp9Ll26xLFjx4iJiQEgJiaGY8eOUVNT06TdmDFj6Nq1KwAhISEYhkFtbe1tlC7innx9ffn881o+/fQshmHw6adn+fzzWnx9NX5CPEer4V9ZWUnfvn0xm80AmM1mAgMDqaysvOln9uzZw7333ku/fv0c23Jycpg8eTILFizg0KFD7VC6iGuYTCbsdjvdu3cHoHv37tjtdkwm3UITz9HulyoffPABW7du5ZVX/rf/c9asWSxcuBCLxUJRURGLFy8mNzcXf3//Nh+3pV9fRDpSfX09nTt3pr6+vsn7uro6rNaeLq5OpG1aDX+bzUZ1dTV2ux2z2Yzdbuf8+fPYbLZmbQ8dOsSzzz7L9u3bGTx4sGO71Wp1vI6IiMBms1FWVsaIESPaXKj6/MWdPPPMcpYu/YljPv+tWzfz05+u0dz+4jZuu8+/d+/ehIaGkp2dDUB2djahoaEEBAQ0aXfkyBGWLVvGSy+9xLe//e0m+6qrqx2vS0pKKC8vZ9CgQU59ERF38sIL6wgM7IWPjw+Bgb144YV1ri5JxCltGu1z8uRJUlJSuHz5Mr169SItLY3BgweTkJBAYmIiYWFhxMfHU15eTt++fR2f27hxIyEhISQnJ3P06FFMJhMWi4XExETGjRvnVKG68hd3YbP5Y7fbm203m81UVn7mgopEmtMyjiLtLDCwF/DVeH/DMBx/AhrqKW5DT/iK3AHf+95oQkIewGQyERLyAN/73mhXlyTiFIW/yC24775BFBQUY7fbKSgo5r77dA9LPIu6fUT+TXz8ZE6eLGuxTUVFBQDdunWjZ8+eXLlyhS+//BKAoKCgVs9x//3fZNeurNsvVqQF6vMXaWczZsTx3nvvNtv+0EPj+eMf93R8QSI3oD5/kXb2xz/u4aGHxuPj4wN8deNXwS+eRlf+IrdhwYLHeOWVna4uQ6QZXfmLiEgzCn8RES+k8BcR8UIKfxERL6TwFxHxQhrtI3etJUsSuHr1qqvLaBfdu3cnPf3Xri5DPEhro3207pzcta5evXrHh2F+PZ//nbZgwWN3/BziXdTtIyLihXTlL3etadOm8be/NZ+GwRNNmzbN1SXIXUbhL3etzMzMu6rbJybmB3f8POI92tTtc+rUKWbOnEl0dDQzZ87k9OnTzdrY7XZSU1OJiopiwoQJZGRktGmfiIh0vDZd+a9evZrHHnuM2NhY9u7dy6pVq9ixY0eTNllZWZw9e5a8vDxqa2uJi4tj1KhR9O/fv8V9InfS3XKjtHv37q4uQe4yrYb/pUuXOHbsGL/97W8BiImJYd26ddTU1DRZxD03N5fp06djMpkICAggKiqKffv28aMf/ajFfSJ3SkdMuKaJ3cRTtRr+lZWV9O3bF7PZDHy1SHVgYCCVlZVNwr+ysrLJQhY2m42qqqpW97VVS+NVRdrL+PHjKS0tdeozQ4c+4FT7kJAQ3n337rgRLZ7LY2746iEv6QhvvrnXqfa3esO3I24Si3e77SmdbTYb1dXV2O124Kubt+fPn8dmszVr9/XydvDV1X6/fv1a3SciIh2v1fDv3bs3oaGhZGdnA5CdnU1oaGiTLh+ASZMmkZGRQWNjIzU1NeTn5xMdHd3qPhER6Xht6vZZs2YNKSkpbN++nV69epGWlgZAQkICiYmJhIWFERsby+HDh5k4cSIATz75JAMGDABocZ+IiHQ8Tewmchs66iEvEWdpGUcREWlG4S8i4oUU/iIiXshjxvmbTD6uLkHkhvRvU9xRa/8uPeaGr4iItB91+4iIeCGFv4iIF1L4i4h4IYW/iIgXUviLiHghhb+IiBdS+IuIeCGFv4iIF1L4i4h4IY+Z3kG8Q0NDA9u3byc3NxdfX18aGxsZN24cTz/9NBaLxWV15efnExgYyJAhQ5z+bGZmJu+99x4vvfQS9fX1bNiwgQMHDmAymTAMgyeeeILJkye3eIyUlBQefPBB5syZc6tfQaQJhb+4leXLl1NXV8euXbvo0aMHDQ0NZGZmUl9f77Lwt9vt5Ofn8+CDD95S+P+7HTt2UFtby1tvvYXZbObq1atcuHChnSpt6vr16/j66n9xuTH9yxC3cfr0afLz8/nrX/9Kjx5fLUJhsViYOXMmdrudtLQ09u/fD8CYMWN45plnMJvNpKSk0KlTJ06fPk1VVRVDhw4lLS2NyspKpk+fznvvvef4wbFkyRLGjx/P1KlT+etf/8ovfvELxw+W5cuXM3ToUIqLi9mwYQPh4eF89NFH/PjHP+bdd9/lb3/7GxkZGcyfP5+4uDh2797Nzp07sdvt9OjRgzVr1jB48GDq6+tZv349xcXF9O3bl8GDBzu+Y1VVFX369MFsNgPQvXt3unfvDkBpaSmpqan861//oq6ujhkzZvCf//mfzf6e3n//fbZs2UJdXR12u52FCxfy6KOPAjB37lyGDRvG4cOH6dy5M0FBQQwYMIAf/vCHABw7doxly5axb98+fHw0IZ1XM0TcRE5OjjFlypQb7nv99deNxx9/3KirqzPq6uqMefPmGa+//rphGIaRnJxszJo1y7h27ZpRV1dnPPLII0ZhYaFhGIYxb948Iz8/3zAMw6ipqTFGjBhhXL161Thz5owxY8YM48qVK4ZhGMaJEyeMcePGGYZhGH//+9+NBx54wPjHP/7hOH9ycrLx2muvOd4fOHDASEhIMOrq6gzDMIz33nvPmDlzpmEYhrFjxw5j/vz5Rn19vfHll18aU6dONZYsWWIYhmEcP37ciIiIMGJiYoznn3/eeOeddxzHvHLliuN4X3zxhfHwww8bn3zySbPz19bWGtevXzcMwzAuXLhgjBkzxqitrTUMwzDmzJljPPHEE0ZDQ4NhGIbxySefGFFRUUZjY6NhGIaxfPly49VXX3XmP4vcpXTlLx7h/fffZ+rUqXTq1AmAadOmkZ+fz2OPPQZAVFQUnTt3BuBb3/oWZ8+eJSIigqlTp7J7924iIyPJzs4mMjKSbt26sX//fs6ePcvs2bMd57h+/ToXL14E4L777mPYsGE3refdd9/l+PHjTJ8+HQDDMLh8+TIAxcXFxMXFYbFYsFgsTJkyhX/84x8AhISE8Je//IUDBw5w8OBB1q1bR0FBAWvXruXatWusWbOG0tJSfHx8OH/+PMePH+f+++9vcu6amhpWrFjBmTNnMJvNfP7555w6dYqhQ4cCMHnyZEd3z/3338+AAQMoKChg6NChvPvuuyxfvvy2/lvI3UHhL27jW9/6FmfOnOHzzz/nG9/4RpN9hmE066b49/dfBz+A2WzGbrcDEB0dzc9+9jM+++wzdu/ezYoVKxztxowZw8aNG5vVcfLkSbp169ZirYZhEB8fz9KlS2+4ryWdO3dm9OjRjB49moceeoj58+ezdu1aNm/ejNVq5YUXXsDX15cFCxZQV1fX7PNr1qxh/PjxvPzyy/j4+BAdHd2k3f+tfe7cubzxxhucPHmSiRMn0rNnzxbrE++goZ7iNgYOHMj48eNZtWoVX3zxBfDVzdbf/e53jBw5kt27d9PQ0EBDQwN79uxh1KhRrR6za9euREZG8vOf/5wvvviC8PBwACIiIti/fz9lZWWOtkeOHLnpcXr06MGVK/+7UPv48ePZu3cvVVVVjjo//vhjAEaNGsXevXu5fv06165dIzs72/G5Dz/80PHbBcDRo0fp378/AFeuXKFfv374+vpy4sQJPvzwwxvWcuXKFe655x58fHwoKirizJkzLf4djBs3jlOnTvHb3/7W8ZuSiK78xa288MILbNu2jfj4eCwWi2Oo57JlyygvL2fq1KkAjB49mhkzZrTpmNOmTWP27NlNrtIHDhzIiy++yMqVK7l27RoNDQ0MHz78pqN5pkyZwvLly9m3b5/jhm9SUhKLFi3CbrfT0NDApEmTePDBB5kxYwalpaU8+uij9OvXj+985zuUl5cDcO7cOdavX09DQwMmk4nevXvz4osvArBo0SKee+453nrrLe69916+853v3LCWp59+mtTUVH79618TEhJCSEhIi9/fZDIRFxdHQUEBDzzwQJv+zuTup5W8RLzA/PnzmTFjBg8//LCrSxE3oW4fkbvYRx99RFRUFD179iQ6OtrV5Ygb0ZW/iIgX0pW/iIgXUviLiHghhb+IiBdS+IuIeCGFv4iIF1L4i4h4of8P23idYQW7TgUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "so_numeric_df[['ConvertedSalary']].boxplot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Find the mean and standard dev\n",
    "std = so_numeric_df['ConvertedSalary'].std()\n",
    "mean = so_numeric_df['ConvertedSalary'].mean()\n",
    "\n",
    "# Calculate the cutoff\n",
    "cut_off = std * 3\n",
    "lower, upper = mean - cut_off, mean + cut_off\n",
    "\n",
    "# Trim the outliers\n",
    "trimmed_df = so_numeric_df[(so_numeric_df['ConvertedSalary'] < upper) \\\n",
    "                           & (so_numeric_df['ConvertedSalary'] > lower)]\n",
    "\n",
    "# The trimmed box plot\n",
    "trimmed_df[['ConvertedSalary']].boxplot()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Did you notice the scale change on the y-axis?**\n",
    "#  Scaling and transforming new data\n",
    "\n",
    "1. Scaling and transforming new data\n",
    "\n",
    "One of the most important aspects of machine learning is the actual application of any model you create on a new data set. For example if you built a model based on historical data, ultimately you will want to apply this model on new data to make predictions.\n",
    "2. Reuse training scalers\n",
    "\n",
    "How you go about doing this depends on what transformations you make to the dataset before you fit the model. For example, if you applied the StandardScaler() to your data before fitting the model, you need to make sure you transform the test data using the same scalar before making predictions. Please do note that the scaler is fitted only on the training data. That is, you fit and transform the training data, but only transform the test data.\n",
    "3. Training transformations for reuse\n",
    "\n",
    "Similarly, if you intend to remove outliers from your test set, you should use the thresholds found on your train set to do so. If you were to use the mean and standard deviation of the test set, it could negatively impact your predictions. Note that it is only in very rare cases that you would want to remove outliers from your test set.\n",
    "4. Why only use training data?\n",
    "\n",
    "So why did we not refit the scaler on the test data or use thresholds from the test data? To avoid data leakage. In real life, you won't have access to the test data, that is, when you have deployed your model in production, you won't have access to future data, so you can't rely on it to make predictions and assess model performance.\n",
    "5. Avoid data leakage!\n",
    "\n",
    "Thus, you should always make sure you calibrate your preprocessing steps only on your training data or else you will overestimate the accuracy of your models. \n",
    "\n",
    "# Train and testing transformations (I)\n",
    "\n",
    "So far you have created scalers based on a column, and then applied the scaler to the same data that it was trained on. When creating machine learning models you will generally build your models on historic data (train set) and apply your model to new unseen data (test set). In these cases you will need to ensure that the same scaling is being applied to both the training and test data.\n",
    "To do this in practice you train the scaler on the train set, and keep the trained scaler to apply it to the test set. You should never retrain a scaler on the test set.\n",
    "\n",
    "For this exercise and the next, we split the so_numeric_df DataFrame into train (so_train_numeric) and test (so_test_numeric) sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "    Instantiate the StandardScaler() as SS_scaler.\n",
    "    Fit the StandardScaler on the Age column.\n",
    "    Transform the Age column in the test set (so_test_numeric).\n",
    "\"\"\"\n",
    "# Import StandardScaler\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "# Apply a standard scaler to the data\n",
    "SS_scaler = StandardScaler()\n",
    "\n",
    "# Fit the standard scaler to the data\n",
    "SS_scaler.fit(so_train_numeric[['Age']])\n",
    "\n",
    "# Transform the test data using the fitted scaler\n",
    "so_test_numeric['Age_ss'] = SS_scaler.transform(so_test_numeric[['Age']])\n",
    "print(so_test_numeric[['Age', 'Age_ss']].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data leakage is one of the most common mistakes data scientists tend to make, and I hope that you won't!\n",
    "# Train and testing transformations (II)\n",
    "\n",
    "Similar to applying the same scaler to both your training and test sets, if you have removed outliers from the train set, you probably want to do the same on the test set as well. Once again you should ensure that you use the thresholds calculated only from the train set to remove outliers from the test set.\n",
    "\n",
    "Similar to the last exercise, we split the so_numeric_df DataFrame into train (so_train_numeric) and test (so_test_numeric) sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_std = so_train_numeric['ConvertedSalary'].mean()\n",
    "train_mean = so_train_numeric['ConvertedSalary'].std()\n",
    "\n",
    "cut_off = train_std * 3\n",
    "train_lower, train_upper = train_mean - cut_off, train_mean + cut_off\n",
    "\n",
    "# Trim the test DataFrame\n",
    "trimmed_df = so_test_numeric[(so_test_numeric['ConvertedSalary'] < train_upper) \\\n",
    "                             & (so_test_numeric['ConvertedSalary'] > train_lower)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Encoding text\n",
    "\n",
    "1. Introduction to Text Encoding\n",
    "\n",
    "So far in this course you have dealt with data that, while sometimes messy, has been generally columnar in nature. When you are faced with text data this is often not going to be the case.\n",
    "2. Standardizing your text\n",
    "\n",
    "Data that is not in a predefined form is called unstructured data, and free text data is a good example of this. Before you can leverage text data in a machine learning model you must first transform it into a series of columns of numbers or vectors. There are many different approaches to doing this and in this chapter we will go through the most common approaches. In this chapter, you will be working with the United States inaugural address dataset, which contains the text for each President's inaugural speech. With George Washington's shown here. It is clear that free text like this is not in tabular form.\n",
    "3. Dataset\n",
    "\n",
    "Before any text analytics can be performed, you must ensure that the text data is in a format that can be used. The speeches have been loaded as a pandas DataFrame called speech_df, with the body of the text in the 'text' column as can be seen by looking at the top five rows using the head() method as shown.\n",
    "4. Removing unwanted characters\n",
    "\n",
    "Most bodies of text will have non letter characters such as punctuation, that will need to be removed before analysis. This can be achieved by using the replace() method along with the str accessor. We have used this in an earlier chapter, but instead of specifying the exact characters you wish to replace, this time you will use patterns called regular expressions. Now unless you go through the text of all speeches, it is difficult to determine which non-letter characters are present in the data. So the easiest way to deal with this to specify a pattern which replaces all non letter characters as shown here. The pattern lowercase a to lowercase z followed by uppercase A to uppercase Z inside square brackets basically indicates include all letter characters. Placing a caret before this pattern inside square brackets negates this, that is, says all non letter characters. So we use the replace() method with this pattern to replace all non letter characters with a white-space as shown here.\n",
    "5. Removing unwanted characters\n",
    "\n",
    "Here you can see the text of the first speech before and after processing. Notice that the hyphen and the colon are missing.\n",
    "6. Standardize the case\n",
    "\n",
    "Once all unwanted characters have been removed you will want to standardize the remaining characters in your text so that they are all lower case. This will ensure that the same word with and without capitalization will not be counted as separate words. You can use the lower() method to achieve this as shown here.\n",
    "7. Length of text\n",
    "\n",
    "Later in this chapter you will work through the creation of features based on the content of different texts, but often there is value in the fundamental characteristics of a passage, such as its length. Using the len() method, you can calculate the number of characters in each speech.\n",
    "8. Word counts\n",
    "\n",
    "Along with the pure character length of the speech, you may want to know how many words are contained in it. The most straight forward way to do this is to split the speech based an any white-spaces, and then count how many words there are after the split. First, you will need to split the text with with the split() method as shown here and\n",
    "9. Word counts\n",
    "\n",
    "then chain the len() method to count the total number of words in each speech.\n",
    "10. Average length of word\n",
    "\n",
    "Finally, one other stat you can calculate is the average word length. Since you already have the total number of characters and the word count, you can simply divide them to obtain the average word length.\n",
    "11. Let's practice!\n",
    "\n",
    "Now it's time for you to practice what you have learned about how to manipulate text. \n",
    "# Cleaning up your text\n",
    "\n",
    "Unstructured text data cannot be directly used in most analyses. Multiple steps need to be taken to go from a long free form string to a set of numeric columns in the right format that can be ingested by a machine learning model. The first step of this process is to standardize the data and eliminate any characters that could cause problems later on in your analytic pipeline.\n",
    "\n",
    "In this chapter you will be working with a new dataset containing the inaugural speeches of the presidents of the United States loaded as speech_df, with the speeches stored in the text column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import pandas\n",
    "import pandas as pd\n",
    "\n",
    "# Import speech_df_csv into speech_df\n",
    "#so_survey_df = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/inaugural_speeches.csv')\n",
    "speech_df = pd.read_csv('/home/abderrazak/ALLINHERE/NLP/Datacamp/inaugural_speeches.csv')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    Fellow-Citizens of the Senate and of the House...\n",
      "1    Fellow Citizens:  I AM again called upon by th...\n",
      "2    WHEN it was first perceived, in early times, t...\n",
      "3    Friends and Fellow-Citizens:  CALLED upon to u...\n",
      "4    PROCEEDING, fellow-citizens, to that qualifica...\n",
      "Name: text, dtype: object\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# Print the first 5 rows of the text column\n",
    "print(# Print the first 5 rows of the text column\n",
    "print(speech_df.text.head(5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0    fellow citizens of the senate and of the house...\n",
      "1    fellow citizens   i am again called upon by th...\n",
      "2    when it was first perceived  in early times  t...\n",
      "3    friends and fellow citizens   called upon to u...\n",
      "4    proceeding  fellow citizens  to that qualifica...\n",
      "Name: text_clean, dtype: object\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/abderrazak/Téléchargements/yes/envs/stuff/lib/python3.7/site-packages/ipykernel_launcher.py:6: FutureWarning: The default value of regex will change from True to False in a future version.\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "    Replace all non letter characters in the text column with a whitespace.\n",
    "    Make all characters in the newly created text_clean column lower case.\n",
    "\"\"\"\n",
    "# Replace all non letter characters with a whitespace\n",
    "speech_df['text_clean'] = speech_df['text'].str.replace('[^a-zA-Z]', ' ')\n",
    "# Change to lower case\n",
    "speech_df['text_clean'] = speech_df['text_clean'].str.lower()\n",
    "# Print the first 5 rows of the text_clean column\n",
    "print(speech_df['text_clean'].head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great, now your text strings have been standardized and cleaned up. You can now use this new column (text_clean) to extract information about the speeches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "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>number_of_words</th>\n",
       "      <th>text_clean</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1432</td>\n",
       "      <td>fellow citizens of the senate and of the house...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>135</td>\n",
       "      <td>fellow citizens   i am again called upon by th...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2323</td>\n",
       "      <td>when it was first perceived  in early times  t...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1736</td>\n",
       "      <td>friends and fellow citizens   called upon to u...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2169</td>\n",
       "      <td>proceeding  fellow citizens  to that qualifica...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   number_of_words                                         text_clean\n",
       "0             1432  fellow citizens of the senate and of the house...\n",
       "1              135  fellow citizens   i am again called upon by th...\n",
       "2             2323  when it was first perceived  in early times  t...\n",
       "3             1736  friends and fellow citizens   called upon to u...\n",
       "4             2169  proceeding  fellow citizens  to that qualifica..."
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speech_df['number_of_words'] = speech_df.text_clean.apply(lambda x: len(x.split()))\n",
    "speech_df[['number_of_words','text_clean']].head() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# High level text features\n",
    "\n",
    "Once the text has been cleaned and standardized you can begin creating features from the data. The most fundamental information you can calculate about free form text is its size, such as its length and number of words. In this exercise (and the rest of this chapter), you will focus on the cleaned/transformed text column (text_clean) you created in the last exercise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                          text_clean  char_cnt  word_cnt  \\\n",
      "0  fellow citizens of the senate and of the house...      8616      1432   \n",
      "1  fellow citizens   i am again called upon by th...       787       135   \n",
      "2  when it was first perceived  in early times  t...     13871      2323   \n",
      "3  friends and fellow citizens   called upon to u...     10144      1736   \n",
      "4  proceeding  fellow citizens  to that qualifica...     12902      2169   \n",
      "\n",
      "   avg_word_length  \n",
      "0         6.016760  \n",
      "1         5.829630  \n",
      "2         5.971158  \n",
      "3         5.843318  \n",
      "4         5.948363  \n"
     ]
    }
   ],
   "source": [
    "# Find the length of each text\n",
    "speech_df['char_cnt'] = speech_df['text_clean'].str.len()\n",
    "\n",
    "# Count the number of words in each text\n",
    "speech_df['word_cnt'] = speech_df['text_clean'].str.split().str.len()\n",
    "\n",
    "# Find the average length of word\n",
    "speech_df['avg_word_length'] = speech_df['char_cnt'] / speech_df['word_cnt']\n",
    "\n",
    "# Print the first 5 rows of these columns\n",
    "print(speech_df[['text_clean', 'char_cnt', 'word_cnt', 'avg_word_length']].head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**These features may appear basic but can be quite useful in ML models.**\n",
    "# Word Count\n",
    "1. Word Count Representation\n",
    "\n",
    "Once high level information has been recorded you can begin creating features based on the actual content of each text.\n",
    "2. Text to columns\n",
    "\n",
    "The most common approach to this is to create a column for each word and record the number of times each particular word appears in each text. This results in a set of columns equal in width to the number of unique words in the dataset, with counts filling each entry. Taking just one sentence we can see that \"of\" occurs 3 tines, \"the\" 2 times and the other words once.\n",
    "3. Initializing the vectorizer\n",
    "\n",
    "While you could of course write a script to do this counting yourself, scikit-learn already has this functionality built in with its CountVectorizer class. As usual, first import CountVectorizer from sklearn dot feature_extraction dot text, then instantiate it by assigning it to a variable name, cv in this case.\n",
    "4. Specifying the vectorizer\n",
    "\n",
    "It may have become apparent that creating a column for every word will result in far too many values for analyses. Thankfully, you can specify arguments when initializing your CountVectorizer to limit this. For example, you can specify the minimum number of texts that a word must be contained in using the argument min_df. If a float is given, the word must appear in at least this percent of documents. This threshold eliminates words that occur so rarely that they would not be useful when generalizing to new texts. Conversely, max_df limits words to only ones that occur below a certain percentage of the data. This can be useful to remove words that occur too frequently to be of any value.\n",
    "5. Fit the vectorizer\n",
    "\n",
    "Once the vectorizer has been instantiated you can then fit it on the data you want to create your features around. This is done by calling the fit() method on relevant column.\n",
    "6. Transforming your text\n",
    "\n",
    "Once the vectorizer has been fit you can call the transform() method on the column you want to transform. This outputs a sparse array, with a row for every text and a column for every word that has been counted.\n",
    "7. Transforming your text\n",
    "\n",
    "To transform this to a non sparse array you can use the toarray() method.\n",
    "8. Getting the features\n",
    "\n",
    "You may notice that the output is an array, with no concept of column names. To get the names of the features that have been generated you can call the get_feature_names() method on the vectorizer which returns a list of the features generated, in the same order that the columns of the converted array are in.\n",
    "9. Fitting and transforming\n",
    "\n",
    "As an aside, while fitting and transforming separately can be useful, particularly when you need to transform a different data set than the one that you fit the vectorizer to, you can accomplish both steps at once using the fit_transform() method.\n",
    "10. Putting it all together\n",
    "\n",
    "Now that you have an array containing the count values of each of the words of interest, and a way to get the feature names you can combine these in a DataFrame as shown here. The add_prefix() method allows you to be able to distinguish these columns in the future.\n",
    "\n",
    "    1 ```out Counts_aback Counts_abandon Counts_abandonment 0 1 0 0 1 0 0 1 2 0 1 0 3 0 1 0 4 0 0 0 ```\n",
    "\n",
    "11. Updating your DataFrame\n",
    "\n",
    "You can now combine this DataFrame with your original DataFrame so they can be used to generate future analytical models using pandas concat method. Checking the DataFrames shape shows the new much wider size. Remember to specify the axis argument to 1 as you want column bind these DataFrames.\n",
    "12. Let's practice!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abandon', 'abandoned', 'abandonment', 'abate', 'abdicated', 'abeyance', 'abhorring', 'abide', 'abiding', 'abilities', 'ability', 'abject', 'able', 'ably', 'abnormal', 'abode', 'abolish', 'abolished', 'abolishing', 'aboriginal', 'aborigines', 'abound', 'abounding', 'abounds', 'about', 'above', 'abraham', 'abreast', 'abridging', 'abroad', 'absence', 'absent', 'absolute', 'absolutely', 'absolutism', 'absorb', 'absorbed', 'absorbing', 'absorbs', 'abstain', 'abstaining', 'abstract', 'abstractions', 'absurd', 'abundance', 'abundant', 'abundantly', 'abuse', 'abused', 'abuses']\n"
     ]
    }
   ],
   "source": [
    "# Import CountVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# Instantiate CountVectorizer\n",
    "cv = CountVectorizer()\n",
    "\n",
    "# Fit the vectorizer\n",
    "cv.fit(speech_df['text_clean'])\n",
    "\n",
    "# Print feature names\n",
    "print(cv.get_feature_names()[:50])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Counting words (II)\n",
    "\n",
    "Once the vectorizer has been fit to the data, it can be used to transform the text to an array representing the word counts. This array will have a row per block of text and a column for each of the features generated by the vectorizer that you observed in the last exercise.\n",
    "\n",
    "The vectorizer to you fit in the last exercise (cv) is available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 1 0 ... 0 0 0]\n",
      " ...\n",
      " [0 1 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]\n",
      " [0 0 0 ... 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "# Apply the vectorizer\n",
    "cv_transformed = cv.transform(speech_df['text_clean'])\n",
    "\n",
    "# Print the full array\n",
    "cv_array = cv_transformed.toarray()\n",
    "print(cv_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(58, 9043)\n"
     ]
    }
   ],
   "source": [
    "# Apply the vectorizer\n",
    "cv_transformed = cv.transform(speech_df['text_clean'])\n",
    "# Print the full array\n",
    "cv_array = cv_transformed.toarray()\n",
    "# Print the shape of cv_array\n",
    "print(cv_transformed.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The speeches have 9043 unique words, which is a lot! In the next exercise, you will see how to create a limited set of features.**\n",
    "# Limiting your features\n",
    "\n",
    "As you have seen, using the CountVectorizer with its default settings creates a feature for every single word in your corpus. This can create far too many features, often including ones that will provide very little analytical value.\n",
    "\n",
    "For this purpose CountVectorizer has parameters that you can set to reduce the number of features:\n",
    "\n",
    "    min_df : Use only words that occur in more than this percentage of documents. This can be used to remove outlier words that will not generalize across texts.\n",
    "    max_df : Use only words that occur in less than this percentage of documents. This is useful to eliminate very common words that occur in every corpus without adding value such as \"and\" or \"the\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(58, 818)\n"
     ]
    }
   ],
   "source": [
    "# Import CountVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "# Specify arguements to limit the number of features generated\n",
    "cv = CountVectorizer(min_df=0.2, max_df=0.8)\n",
    "# Fit, transform, and convert into array\n",
    "cv_transformed = cv.fit_transform(speech_df['text_clean'])\n",
    "cv_array = cv_transformed.toarray()\n",
    "# Print the array shape\n",
    "print(cv_array.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Did you notice that the number of features (unique words) greatly reduced from 9043 to 818?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                Name         Inaugural Address                      Date  \\\n",
      "0  George Washington   First Inaugural Address  Thursday, April 30, 1789   \n",
      "1  George Washington  Second Inaugural Address     Monday, March 4, 1793   \n",
      "2         John Adams         Inaugural Address   Saturday, March 4, 1797   \n",
      "3   Thomas Jefferson   First Inaugural Address  Wednesday, March 4, 1801   \n",
      "4   Thomas Jefferson  Second Inaugural Address     Monday, March 4, 1805   \n",
      "\n",
      "                                                text  \\\n",
      "0  Fellow-Citizens of the Senate and of the House...   \n",
      "1  Fellow Citizens:  I AM again called upon by th...   \n",
      "2  WHEN it was first perceived, in early times, t...   \n",
      "3  Friends and Fellow-Citizens:  CALLED upon to u...   \n",
      "4  PROCEEDING, fellow-citizens, to that qualifica...   \n",
      "\n",
      "                                          text_clean  number_of_words  \\\n",
      "0  fellow citizens of the senate and of the house...             1432   \n",
      "1  fellow citizens   i am again called upon by th...              135   \n",
      "2  when it was first perceived  in early times  t...             2323   \n",
      "3  friends and fellow citizens   called upon to u...             1736   \n",
      "4  proceeding  fellow citizens  to that qualifica...             2169   \n",
      "\n",
      "   char_cnt  word_cnt  avg_word_length  Counts_abiding  ...  Counts_women  \\\n",
      "0      8616      1432         6.016760               0  ...             0   \n",
      "1       787       135         5.829630               0  ...             0   \n",
      "2     13871      2323         5.971158               0  ...             0   \n",
      "3     10144      1736         5.843318               0  ...             0   \n",
      "4     12902      2169         5.948363               0  ...             0   \n",
      "\n",
      "   Counts_words  Counts_work  Counts_wrong  Counts_year  Counts_years  \\\n",
      "0             0            0             0            0             1   \n",
      "1             0            0             0            0             0   \n",
      "2             0            0             0            2             3   \n",
      "3             0            1             2            0             0   \n",
      "4             0            0             0            2             2   \n",
      "\n",
      "   Counts_yet  Counts_you  Counts_young  Counts_your  \n",
      "0           0           5             0            9  \n",
      "1           0           0             0            1  \n",
      "2           0           0             0            1  \n",
      "3           2           7             0            7  \n",
      "4           2           4             0            4  \n",
      "\n",
      "[5 rows x 827 columns]\n"
     ]
    }
   ],
   "source": [
    "# Create a DataFrame with these features\n",
    "cv_df = pd.DataFrame(cv_array, \n",
    "                     columns=cv.get_feature_names()).add_prefix('Counts_')\n",
    "\n",
    "# Add the new columns to the original DataFrame\n",
    "speech_df_new = pd.concat([speech_df, cv_df], axis=1, sort=False)\n",
    "print(speech_df_new.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  With the new features combined with the orginial DataFrame they can be now used for ML models or analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Term frequency-inverse document frequency\n",
    "\n",
    "1. Tf-Idf Representation\n",
    "\n",
    "While counts of occurrences of words can be a good first step towards encoding your text to build models, it has some limitations. The main issue is counts will be much higher for very common even when they occur across all texts, providing little value as a distinguishing feature.\n",
    "2. Introducing TF-IDF\n",
    "\n",
    "Take for example the counts of the word \"the\" shown here, with plentiful occurrences in every row. To limit these common words from overpowering your model some form of normalization can be used. One of the most effective approaches to do this is called \"Term Frequency Inverse Document Frequency\" or TF-IDF.\n",
    "3. TF-IDF\n",
    "\n",
    "TF-IDF divides number of times a word occurs in the document by a measure of what proportion of the documents a word occurs in all documents. This has the effect of reducing the value of common words, while increasing the weight of words that do not occur in many documents.\n",
    "4. Importing the vectorizer\n",
    "\n",
    "To use a TF-IDF vectorizer, the approach is very similar to how you applied a count vectorizer. First you must import TfidfVectorizer() from sklearn dot feature_extraction dot text, then you assign it to a variable name. Lets use tv in this case.\n",
    "5. Max features and stopwords\n",
    "\n",
    "Similar to when you were working with the Count vectorizer where you could limit the number of features created by specifying arguments when initializing TfidfVectorizer, you can specify the maximum number of features using max_features which will only use the 100 most common words. We will also specify the vectorizer to omit a set of stop_words, these are a predefined list of the most common english words such as \"and\" or \"the\". You can use scikit-learn's built in list, load your own, or use lists provided by other python libraries.\n",
    "6. Fitting your text\n",
    "\n",
    "Once the vectorizer has been specified you can fit it, and apply it to the text that you want to transform. Note that here we are fitting and transforming the train data, a subset of the original data.\n",
    "7. Putting it all together\n",
    "\n",
    "As before, you combine the TF-IDF values along with the feature names in a DataFrame as shown here.\n",
    "8. Inspecting your transforms\n",
    "\n",
    "After transforming your data you should always check how the different words are being valued, and see which words are receiving the highest scores through the process. This will help you understand if the features being generated make sense or not. One ad hoc method is to isolate a single row of the transformed DataFrame (`tv_df` in this case), using the iloc accessor, and then sorting the values in the row in descending order as shown here. These top ranked values make sense for the text of a presidential speech.\n",
    "9. Applying the vectorizer to new data\n",
    "\n",
    "So how do you apply this transformation on the test set? As mentioned before, you should preprocess your test data using the transformations made on the train data only. To ensure that the same features are created you should use the same vectorizer that you fit on the training data. So first transform the test data using the tv vectorizer and then recreate the test data set by combining the TF-IDF values, feature names, and other columns.\n",
    "10. Let's practice!\n",
    "\n",
    "So, now you also know about TF-IDF! Great, it's time for you to implement this. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   TFIDF_action  TFIDF_administration  TFIDF_america  TFIDF_american  \\\n",
      "0      0.000000              0.133415       0.000000        0.105388   \n",
      "1      0.000000              0.261016       0.266097        0.000000   \n",
      "2      0.000000              0.092436       0.157058        0.073018   \n",
      "3      0.000000              0.092693       0.000000        0.000000   \n",
      "4      0.041334              0.039761       0.000000        0.031408   \n",
      "\n",
      "   TFIDF_americans  TFIDF_believe  TFIDF_best  TFIDF_better  TFIDF_change  \\\n",
      "0              0.0       0.000000    0.000000      0.000000      0.000000   \n",
      "1              0.0       0.000000    0.000000      0.000000      0.000000   \n",
      "2              0.0       0.000000    0.026112      0.060460      0.000000   \n",
      "3              0.0       0.090942    0.117831      0.045471      0.053335   \n",
      "4              0.0       0.000000    0.067393      0.039011      0.091514   \n",
      "\n",
      "   TFIDF_citizens  ...  TFIDF_things  TFIDF_time  TFIDF_today  TFIDF_union  \\\n",
      "0        0.229644  ...      0.000000    0.045929          0.0     0.136012   \n",
      "1        0.179712  ...      0.000000    0.000000          0.0     0.000000   \n",
      "2        0.106072  ...      0.032030    0.021214          0.0     0.062823   \n",
      "3        0.223369  ...      0.048179    0.000000          0.0     0.094497   \n",
      "4        0.273760  ...      0.082667    0.164256          0.0     0.121605   \n",
      "\n",
      "   TFIDF_united  TFIDF_war  TFIDF_way  TFIDF_work  TFIDF_world  TFIDF_years  \n",
      "0      0.203593   0.000000   0.060755    0.000000     0.045929     0.052694  \n",
      "1      0.199157   0.000000   0.000000    0.000000     0.000000     0.000000  \n",
      "2      0.070529   0.024339   0.000000    0.000000     0.063643     0.073018  \n",
      "3      0.000000   0.036610   0.000000    0.039277     0.095729     0.000000  \n",
      "4      0.030338   0.094225   0.000000    0.000000     0.054752     0.062817  \n",
      "\n",
      "[5 rows x 100 columns]\n"
     ]
    }
   ],
   "source": [
    "# Import TfidfVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "# Instantiate TfidfVectorizer\n",
    "tv = TfidfVectorizer(max_features=100, stop_words='english')\n",
    "\n",
    "# Fit the vectroizer and transform the data\n",
    "tv_transformed = tv.fit_transform(speech_df['text_clean'])\n",
    "\n",
    "# Create a DataFrame with these features\n",
    "tv_df = pd.DataFrame(tv_transformed.toarray(), \n",
    "                     columns=tv.get_feature_names()).add_prefix('TFIDF_')\n",
    "print(tv_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspecting Tf-idf values\n",
    "\n",
    "After creating Tf-idf features you will often want to understand what are the most highest scored words for each corpus. This can be achieved by isolating the row you want to examine and then sorting the the scores from high to low.\n",
    "\n",
    "The DataFrame from the last exercise (tv_df) is available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TFIDF_government    0.367430\n",
      "TFIDF_public        0.333237\n",
      "TFIDF_present       0.315182\n",
      "TFIDF_duty          0.238637\n",
      "TFIDF_country       0.229644\n",
      "Name: 0, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Isolate the row to be examined\n",
    "sample_row = tv_df.iloc[0]\n",
    "\n",
    "# Print the top 5 words of the sorted output\n",
    "print(sample_row.sort_values(ascending=False).head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Do you think these scores make sense for the corresponding words?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Transforming unseen data\n",
    "\n",
    "When creating vectors from text, any transformations that you perform before training a machine learning model, you also need to apply on the new unseen (test) data. To achieve this follow the same approach from the last chapter: fit the vectorizer only on the training data, and apply it to the test data.\n",
    "\n",
    "For this exercise the speech_df DataFrame has been split in two:\n",
    "\n",
    "    train_speech_df: The training set consisting of the first 45 speeches.\n",
    "    test_speech_df: The test set consisting of the remaining speeches.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_speech_df=speech_df.iloc[0:45]\n",
    "test_speech_df=speech_df.iloc[45:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   TFIDF_action  TFIDF_administration  TFIDF_america  TFIDF_american  \\\n",
      "0      0.000000              0.029540       0.233954        0.082703   \n",
      "1      0.000000              0.000000       0.547457        0.036862   \n",
      "2      0.000000              0.000000       0.126987        0.134669   \n",
      "3      0.037094              0.067428       0.267012        0.031463   \n",
      "4      0.000000              0.000000       0.221561        0.156644   \n",
      "\n",
      "   TFIDF_authority  TFIDF_best  TFIDF_business  TFIDF_citizens  \\\n",
      "0         0.000000    0.000000        0.000000        0.022577   \n",
      "1         0.000000    0.036036        0.000000        0.015094   \n",
      "2         0.000000    0.131652        0.000000        0.000000   \n",
      "3         0.039990    0.061516        0.050085        0.077301   \n",
      "4         0.028442    0.087505        0.000000        0.109959   \n",
      "\n",
      "   TFIDF_commerce  TFIDF_common  ...  TFIDF_subject  TFIDF_support  \\\n",
      "0             0.0      0.000000  ...            0.0       0.000000   \n",
      "1             0.0      0.000000  ...            0.0       0.019296   \n",
      "2             0.0      0.046997  ...            0.0       0.000000   \n",
      "3             0.0      0.000000  ...            0.0       0.098819   \n",
      "4             0.0      0.023428  ...            0.0       0.023428   \n",
      "\n",
      "   TFIDF_time  TFIDF_union  TFIDF_united  TFIDF_war  TFIDF_way  TFIDF_work  \\\n",
      "0    0.115378     0.000000      0.024648   0.079050   0.033313    0.000000   \n",
      "1    0.092567     0.000000      0.000000   0.052851   0.066817    0.078999   \n",
      "2    0.075151     0.000000      0.080272   0.042907   0.054245    0.096203   \n",
      "3    0.210690     0.000000      0.056262   0.030073   0.038020    0.235998   \n",
      "4    0.187313     0.131913      0.040016   0.021389   0.081124    0.119894   \n",
      "\n",
      "   TFIDF_world  TFIDF_years  \n",
      "0     0.299983     0.134749  \n",
      "1     0.277701     0.126126  \n",
      "2     0.225452     0.043884  \n",
      "3     0.237026     0.061516  \n",
      "4     0.299701     0.153133  \n",
      "\n",
      "[5 rows x 100 columns]\n"
     ]
    }
   ],
   "source": [
    "# Instantiate TfidfVectorizer\n",
    "tv = TfidfVectorizer(max_features=100, stop_words='english')\n",
    "\n",
    "# Fit the vectroizer and transform the data\n",
    "tv_transformed = tv.fit_transform(train_speech_df['text_clean'])\n",
    "\n",
    "# Transform test data\n",
    "test_tv_transformed = tv.transform(test_speech_df['text_clean'])\n",
    "\n",
    "# Create new features for the test set\n",
    "test_tv_df = pd.DataFrame(test_tv_transformed.toarray(), \n",
    "                          columns=tv.get_feature_names()).add_prefix('TFIDF_')\n",
    "print(test_tv_df.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inspecting Tf-idf values\n",
    "\n",
    "After creating Tf-idf features you will often want to understand what are the most highest scored words for each corpus. This can be achieved by isolating the row you want to examine and then sorting the the scores from high to low.\n",
    "\n",
    "The DataFrame from the last exercise (tv_df) is available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TFIDF_government    0.367430\n",
      "TFIDF_public        0.333237\n",
      "TFIDF_present       0.315182\n",
      "TFIDF_duty          0.238637\n",
      "TFIDF_country       0.229644\n",
      "Name: 0, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Isolate the row to be examined\n",
    "sample_row = tv_df.iloc[0]\n",
    "\n",
    "# Print the top 5 words of the sorted output\n",
    "print(sample_row.sort_values(ascending=False).head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TFIDF_action            0.000000\n",
       "TFIDF_administration    0.133415\n",
       "TFIDF_america           0.000000\n",
       "TFIDF_american          0.105388\n",
       "TFIDF_americans         0.000000\n",
       "                          ...   \n",
       "TFIDF_war               0.000000\n",
       "TFIDF_way               0.060755\n",
       "TFIDF_work              0.000000\n",
       "TFIDF_world             0.045929\n",
       "TFIDF_years             0.052694\n",
       "Name: 0, Length: 100, dtype: float64"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample_row"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N-grams\n",
    " Bag of words and N-grams\n",
    "\n",
    "So far you have looked at individual words on their own without any context or word order, this approach is called a bag-of-words model, as the words are treated as if they are being drawn from a bag with no concept of order or grammar. While analyzing the occurrences of individual words can be a valuable way to create features from a piece of text, you will notice that individual words can loose all their context/meaning when viewed independently.\n",
    "2. Issues with bag of words\n",
    "\n",
    "Take for example the word 'happy' shown here. One would assume it was used in a positive context, but if in reality it was used in the phrase 'not happy' this assumption would be incorrect. Similarly if the phrase was extended to 'never not happy' the connotation changes again. One common method to retain at least some concept of word order in a text is to instead use multiple consecutive words like pairs (bi-gram) or three consecutive words (tri-grams). This maintains at least some ordering information while at the same time allowing for the creation of a reasonable set of features.\n",
    "3. Using N-grams\n",
    "\n",
    "To leverage n-grams in your own models an additional argument \"ngram_range\", can be specified when instantiating your TF-IDF vectorizer. The values assigned to the argument are the minimum and maximum length of n-grams to be included. In this case you would only be looking at bi-grams (n-grams with two words) Printing the bi-gram features created we can see the pairs of words instead of single words.\n",
    "4. Finding common words\n",
    "\n",
    "As mentioned in the last video, when creating new features, you should always take time to check your work, and ensure that the features you are creating make sense. A good way to check your n-grams is to see what are the most common values being recorded. This can be done by summing the values of your DataFrame of count values that you created using the sum() method.\n",
    "5. Finding common words\n",
    "\n",
    "After sorting the values in descending order you can see the most commonly occurring values. It comes as no surprise that the most commonly occurring bi-gram in a dataset of US president's speeches is \"United States\" which indicates that the features being created make sense.\n",
    "6. Let's practice!\n",
    "\n",
    "You should now be able to try out many different combinations of text based features. It can be interesting to go further and explore the most common longer n-grams such as three word sequences called tri-grams. \n",
    "# Using longer n-grams\n",
    "\n",
    "So far you have created features based on individual words in each of the texts. This can be quite powerful when used in a machine learning model but you may be concerned that by looking at words individually a lot of the context is being ignored. To deal with this when creating models you can use n-grams which are sequence of n words grouped together. For example:\n",
    "\n",
    "    bigrams: Sequences of two consecutive words\n",
    "    trigrams: Sequences of two consecutive words\n",
    "\n",
    "These can be automatically created in your dataset by specifying the ngram_range argument as a tuple (n1, n2) where all n-grams in the n1 to n2 range are included.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ability preserve protect', 'agriculture commerce manufactures', 'america ideal freedom', 'amity mutual concession', 'anchor peace home', 'ask bow heads', 'best ability preserve', 'best interests country', 'bless god bless', 'bless united states', 'chief justice mr', 'children children children', 'citizens united states', 'civil religious liberty', 'civil service reform', 'commerce united states', 'confidence fellow citizens', 'congress extraordinary session', 'constitution does expressly', 'constitution united states', 'coordinate branches government', 'day task people', 'defend constitution united', 'distinction powers granted', 'distinguished guests fellow', 'does expressly say', 'equal exact justice', 'era good feeling', 'executive branch government', 'faithfully execute office', 'fellow citizens assembled', 'fellow citizens called', 'fellow citizens large', 'fellow citizens world', 'form perfect union', 'general welfare secure', 'god bless america', 'god bless god', 'good greatest number', 'government peace war', 'government united states', 'granted federal government', 'great body people', 'great political parties', 'greatest good greatest', 'guests fellow citizens', 'invasion wars powers', 'land new promise', 'laws faithfully executed', 'letter spirit constitution', 'liberty pursuit happiness', 'life liberty pursuit', 'local self government', 'make hard choices', 'men women children', 'mr chief justice', 'mr majority leader', 'mr president vice', 'mr speaker mr', 'mr vice president', 'nation like person', 'new breeze blowing', 'new states admitted', 'north south east', 'oath prescribed constitution', 'office president united', 'passed generation generation', 'peace shall strive', 'people united states', 'physical moral political', 'policy united states', 'power general government', 'preservation general government', 'preservation sacred liberty', 'preserve protect defend', 'president united states', 'president vice president', 'promote general welfare', 'proof confidence fellow', 'protect defend constitution', 'protection great interests', 'reform civil service', 'reserved states people', 'respect individual human', 'right self government', 'secure blessings liberty', 'south east west', 'sovereignty general government', 'states admitted union', 'territories united states', 'thank god bless', 'turning away old', 'united states america', 'united states best', 'united states government', 'united states great', 'united states maintain', 'united states territory', 'vice president mr', 'welfare secure blessings']\n"
     ]
    }
   ],
   "source": [
    "# Import CountVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# Instantiate a trigram vectorizer\n",
    "cv_trigram_vec = CountVectorizer(max_features=100, \n",
    "                                 stop_words='english', \n",
    "                                 ngram_range = (3,3))\n",
    "\n",
    "# Fit and apply trigram vectorizer\n",
    "cv_trigram = cv_trigram_vec.fit_transform(speech_df['text_clean'])\n",
    "\n",
    "# Print the trigram features\n",
    "print(cv_trigram_vec.get_feature_names())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding the most common words\n",
    "\n",
    "Its always advisable once you have created your features to inspect them to ensure that they are as you would expect. This will allow you to catch errors early, and perhaps influence what further feature engineering you will need to do.\n",
    "\n",
    "The vectorizer (cv) you fit in the last exercise and the sparse array consisting of word counts (cv_trigram) is available in your workspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counts_constitution united states    20\n",
      "Counts_people united states          13\n",
      "Counts_mr chief justice              10\n",
      "Counts_preserve protect defend       10\n",
      "Counts_president united states        8\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "# Create a DataFrame of the features\n",
    "cv_tri_df =pd.DataFrame(cv_trigram.toarray(), \n",
    "                 columns=cv_trigram_vec.get_feature_names()).add_prefix('Counts_')\n",
    "\n",
    "# Print the top 5 words in the sorted output\n",
    "print(cv_tri_df.sum().sort_values(ascending=False).head(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**That the most common trigram is constitution united states makes a lot of sense for US presidents speeches.**\n",
    "\n",
    "1. Wrap-up\n",
    "\n",
    "Congratulations on completing the course “Feature Engineering for machine learning in python”. This course set out to teach you about understanding your data types and how best to prepare your dataset for a machine learning model. Let's take a moment to recap what you have covered.\n",
    "\n",
    "2. Chapter 1\n",
    "\n",
    "In chapter one, you learned how to better understand the underlying types of data contained in your data set, how to create features out of categorical columns and how to bin continuous columns.\n",
    "\n",
    "\n",
    "3. Chapter 2\n",
    "\n",
    "In chapter two, we moved on to exploring how to deal with some of the challenges of real world data, such as missing values and non desirable characters in your data.\n",
    "\n",
    "4. Chapter 3\n",
    "\n",
    "Chapter 3 discussed how different distributions can effect your models and how to mitigate it, and different ways to deal with spurious outlier values in your dataset.\n",
    "\n",
    "5. Chapter 4\n",
    "\n",
    "Finally in chapter 4, we explored how to deal with non tabular data such as free text and different ways to encode it for use with a machine learning model.\n",
    "\n",
    "6. Next steps\n",
    "\n",
    "Hopefully these newly learned skills should benefit both your personal projects and your professional careers. A great place to test out these skills is to try applying them to kaggle competitions or any of your own pet projects to see if they improve your results. Or, if you want to explore these topics further, perhaps you could try out some of the other related courses on datacamp.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a pairplot and color the points using the 'Gender' feature\n",
    "sns.pairplot(ansur_df_1, hue='Gender', diag_kind='hist')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}