{ "cells": [ { "cell_type": "markdown", "id": "fantastic-invitation", "metadata": {}, "source": [ "# Machine Learning with Python\n", "\n", "The aim of this lab is to implement a complete ML project in python. We will go through the steps of data exploration, cleaning and transformation followed by model training and selection.\n", "\n", "The lab consists of two parts. The first part is an interactive tutorial adapted from [Aurélien Géron's excellent ML book](https://github.com/ageron/handson-ml2) with some modifications to make it a classification tutorial instead of a regression one. We will learn to classify neighborhoods by median house value. The tutorial will contains conceptual questions as well as fill-in code that we'll give you a few minutes to write.\n", "\n", "In the second part of this lab, you will pick a dataset of your own choosing and go through the steps mentioned above. You should try at least 3 different classes of models, and one of them should be an `xgboost` classifier or regressor. We recommend that you pick a dataset from [Kaggle](https://www.kaggle.com/). We will be very flexible in grading this lab; we just need to see that you've taken the right steps. You should submit your notebook to gradescope. Submission instructions will be given on Piazza." ] }, { "cell_type": "markdown", "id": "external-blend", "metadata": {}, "source": [ "## Setup\n", "Run the following code to install libraries and download required files." ] }, { "cell_type": "code", "execution_count": 26, "id": "european-guyana", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: sklearn in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (0.0)\n", "Requirement already satisfied: matplotlib in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (3.5.1)\n", "Requirement already satisfied: numpy in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (1.22.2)\n", "Requirement already satisfied: pandas in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (1.4.1)\n", "Requirement already satisfied: xgboost in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (1.5.2)\n", "Requirement already satisfied: scikit-learn in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from sklearn) (1.0.2)\n", "Requirement already satisfied: pillow>=6.2.0 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (9.0.1)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (1.3.2)\n", "Requirement already satisfied: pyparsing>=2.2.1 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (3.0.7)\n", "Requirement already satisfied: fonttools>=4.22.0 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (4.29.1)\n", "Requirement already satisfied: python-dateutil>=2.7 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (2.8.2)\n", "Requirement already satisfied: cycler>=0.10 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (0.11.0)\n", "Requirement already satisfied: packaging>=20.0 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from matplotlib) (21.3)\n", "Requirement already satisfied: pytz>=2020.1 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from pandas) (2021.3)\n", "Requirement already satisfied: scipy in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from xgboost) (1.8.0)\n", "Requirement already satisfied: six>=1.5 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", "Requirement already satisfied: joblib>=0.11 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from scikit-learn->sklearn) (1.1.0)\n", "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/amlatyr/.local/share/virtualenvs/lab_3-pqPrnF0_/lib/python3.9/site-packages (from scikit-learn->sklearn) (3.1.0)\n" ] } ], "source": [ "import sys\n", "assert sys.version_info >= (3, 9) # You might later get errors if you have a lower version.\n", "\n", "# Install necessary libraries\n", "!pip install sklearn matplotlib numpy pandas xgboost\n", "\n", "# Do all necessary imports\n", "import sklearn\n", "import numpy as np\n", "import pandas as pd\n", "import os\n", "%matplotlib inline\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "import xgboost\n", "mpl.rc('axes', labelsize=14)\n", "mpl.rc('xtick', labelsize=12)\n", "mpl.rc('ytick', labelsize=12)" ] }, { "cell_type": "code", "execution_count": 27, "id": "modified-depth", "metadata": {}, "outputs": [], "source": [ "# Download necessary files\n", "import tarfile\n", "import urllib.request\n", "\n", "def perform_downloads():\n", " # Download data file\n", " root_url = \"https://raw.githubusercontent.com/ageron/handson-ml2/master/\"\n", " housing_url = f\"{root_url}datasets/housing/housing.tgz\"\n", " tgz_path = \"housing.tgz\"\n", " urllib.request.urlretrieve(housing_url, tgz_path)\n", " housing_tgz = tarfile.open(tgz_path)\n", " housing_tgz.extractall(path=\"./\")\n", " housing_tgz.close()\n", " \n", "\n", "def to_classification():\n", " # Original dataset was for a regression tasks.\n", " # Transform it to classification task.\n", " classes = ['LOW', 'MEDIUM', 'HIGH']\n", " housing = pd.read_csv('housing.csv')\n", " housing[\"house_value_class\"] = pd.cut(housing[\"median_house_value\"], bins=[0.0, 200000, 400000, np.inf], labels=classes)\n", " housing.drop('median_house_value', axis=1, inplace=True)\n", " housing.to_csv(\"housing_classification.csv\", index=False)\n", "\n", " \n", " \n", "perform_downloads()\n", "to_classification()" ] }, { "cell_type": "markdown", "id": "metallic-rally", "metadata": {}, "source": [ "## Preliminary\n", "Before we begin, we split our data into a training and a testing set. All our learning will be done on the training set. The testing set is going to used only once after training.**Q: Why is a good idea?**\n", "\n", "You could manually implement the splitting logic, but Scikit-Learn has builtin functions that do this for us. There are many splitting methodologies, but the simplest one that works well for us is as follows" ] }, { "cell_type": "code", "execution_count": 28, "id": "young-candidate", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "data size=20640; training size=16512; testing size=4128\n" ] } ], "source": [ "# Import splitting function\n", "from sklearn.model_selection import train_test_split\n", "\n", "# Read data\n", "data = pd.read_csv(\"housing_classification.csv\")\n", "\n", "# Split data. 80% is used as training; 20% as testing. The data will be randomly split\n", "train_set, test_set = train_test_split(data, test_size=0.2, random_state=37)\n", "\n", "print(f\"data size={len(data)}; training size={len(train_set)}; testing size={len(test_set)}\")" ] }, { "cell_type": "markdown", "id": "unnecessary-words", "metadata": {}, "source": [ "## Data Exploration" ] }, { "cell_type": "code", "execution_count": 29, "id": "trained-style", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
longitudelatitudehousing_median_agetotal_roomstotal_bedroomspopulationhouseholdsmedian_incomeocean_proximityhouse_value_class
9694-121.6336.6824.02591.0739.03243.0702.02.1766<1H OCEANLOW
18859-122.0941.3252.04019.0824.01728.0706.02.2462INLANDLOW
11074-117.8633.8034.01793.0480.01722.0441.02.8235<1H OCEANLOW
10858-117.8633.7136.0191.042.0208.037.03.3750<1H OCEANLOW
16462-121.2738.1111.03163.0794.02106.0762.02.4482INLANDLOW
\n", "
" ], "text/plain": [ " longitude latitude housing_median_age total_rooms total_bedrooms \\\n", "9694 -121.63 36.68 24.0 2591.0 739.0 \n", "18859 -122.09 41.32 52.0 4019.0 824.0 \n", "11074 -117.86 33.80 34.0 1793.0 480.0 \n", "10858 -117.86 33.71 36.0 191.0 42.0 \n", "16462 -121.27 38.11 11.0 3163.0 794.0 \n", "\n", " population households median_income ocean_proximity house_value_class \n", "9694 3243.0 702.0 2.1766 <1H OCEAN LOW \n", "18859 1728.0 706.0 2.2462 INLAND LOW \n", "11074 1722.0 441.0 2.8235 <1H OCEAN LOW \n", "10858 208.0 37.0 3.3750 <1H OCEAN LOW \n", "16462 2106.0 762.0 2.4482 INLAND LOW " ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Read data, and take look at the attributes\n", "housing = train_set # Rename for convenience\n", "housing.head()" ] }, { "cell_type": "markdown", "id": "occupational-therapy", "metadata": {}, "source": [ "Each row contains housing data aggregated by *block group*, which is how the US officially reports housing data. Our goal is to predict the housing value class (low, medium or high) given information about a block. Let's take a look at the columns within the dataframe." ] }, { "cell_type": "code", "execution_count": 41, "id": "israeli-natural", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Int64Index: 16512 entries, 9694 to 1935\n", "Data columns (total 10 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 longitude 16512 non-null float64\n", " 1 latitude 16512 non-null float64\n", " 2 housing_median_age 16512 non-null float64\n", " 3 total_rooms 16512 non-null float64\n", " 4 total_bedrooms 16345 non-null float64\n", " 5 population 16512 non-null float64\n", " 6 households 16512 non-null float64\n", " 7 median_income 16512 non-null float64\n", " 8 ocean_proximity 16512 non-null object \n", " 9 house_value_class 16512 non-null object \n", "dtypes: float64(8), object(2)\n", "memory usage: 1.4+ MB\n" ] } ], "source": [ "# Info gives a quick summary\n", "housing.info()" ] }, { "cell_type": "markdown", "id": "promotional-worcester", "metadata": {}, "source": [ "First, note that the `total_bedrooms` columns contains missing values. \n", "**Q: What techniques can we use to handle them?** \n", "\n", "---\n", "\n", "We also note that only the target class `house_value_class` and `ocean_proximity` are categorical. In the following code, find the distinct values of `ocean_proximity`." ] }, { "cell_type": "code", "execution_count": 53, "id": "refined-youth", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['LOW' 'MEDIUM' 'HIGH']\n", "['<1H OCEAN' 'INLAND' 'NEAR BAY' 'NEAR OCEAN' 'ISLAND']\n" ] } ], "source": [ "# TODO: Distinct valus of house_value_class\n", "print(housing.house_value_class.unique())\n", "\n", "# TODO: Distinct values of ocean_proximity.\n", "print(housing.ocean_proximity.unique())" ] }, { "cell_type": "markdown", "id": "previous-geneva", "metadata": {}, "source": [ "**Q: What's the standard way of dealing with categorical features in ML algorithms?**\n", "\n", "----\n", "\n", "As for the numerical attributes, we can quickly summarize their distribution as follows:" ] }, { "cell_type": "code", "execution_count": 32, "id": "timely-china", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
longitudelatitudehousing_median_agetotal_roomstotal_bedroomspopulationhouseholdsmedian_income
count16512.00000016512.00000016512.00000016512.00000016345.00000016512.00000016512.00000016512.000000
mean-119.56852235.62685428.6277862644.478622539.3028451428.389777500.4216933.877276
std2.0089382.13758912.5891422187.314665422.0623831131.002342382.4234111.908253
min-124.35000032.5400001.0000008.0000001.0000003.0000001.0000000.499900
25%-121.80000033.93000018.0000001445.000000295.000000787.000000279.0000002.566350
50%-118.49000034.25000029.0000002128.000000435.0000001167.000000410.0000003.541700
75%-118.00000037.71000037.0000003160.000000648.0000001728.000000607.0000004.750000
max-114.31000041.95000052.00000037937.0000005471.00000035682.0000005189.00000015.000100
\n", "
" ], "text/plain": [ " longitude latitude housing_median_age total_rooms \\\n", "count 16512.000000 16512.000000 16512.000000 16512.000000 \n", "mean -119.568522 35.626854 28.627786 2644.478622 \n", "std 2.008938 2.137589 12.589142 2187.314665 \n", "min -124.350000 32.540000 1.000000 8.000000 \n", "25% -121.800000 33.930000 18.000000 1445.000000 \n", "50% -118.490000 34.250000 29.000000 2128.000000 \n", "75% -118.000000 37.710000 37.000000 3160.000000 \n", "max -114.310000 41.950000 52.000000 37937.000000 \n", "\n", " total_bedrooms population households median_income \n", "count 16345.000000 16512.000000 16512.000000 16512.000000 \n", "mean 539.302845 1428.389777 500.421693 3.877276 \n", "std 422.062383 1131.002342 382.423411 1.908253 \n", "min 1.000000 3.000000 1.000000 0.499900 \n", "25% 295.000000 787.000000 279.000000 2.566350 \n", "50% 435.000000 1167.000000 410.000000 3.541700 \n", "75% 648.000000 1728.000000 607.000000 4.750000 \n", "max 5471.000000 35682.000000 5189.000000 15.000100 " ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "housing.describe()" ] }, { "cell_type": "markdown", "id": "difficult-tribe", "metadata": {}, "source": [ "We see that some columns (e.g., `longititude` vs `population`) have very different ranges of values. \n", "**Q: What's the standard way to deal with such differences in numerical data distributions?**\n", "\n", "----\n", "\n", "While these numbers are informative, plots are usually a lot more intuitive. Using [pandas.DataFrame.hist](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.hist.html), show a histogram for all the numerical columns. \n", "**Q: Briefly describe what stands out most to you?**" ] }, { "cell_type": "code", "execution_count": 54, "id": "creative-context", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[,\n", " ,\n", " ],\n", " [,\n", " ,\n", " ],\n", " [,\n", " , ]],\n", " dtype=object)" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# TODO: Plot histograms (< 2min)\n", "# Hint: Set figure size to (15, 15), and the number of bins to 50 for good formatting.\n", "housing.hist(bins=50, figsize=(15,15))" ] }, { "cell_type": "markdown", "id": "continued-increase", "metadata": {}, "source": [ "It's also possible to visualize multiple attributes together. Using [pandas.DataFrame.plot](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.plot.html), plot the relationship between total number of rooms and population. \n", "\n", "**Q: What do you notice?**" ] }, { "cell_type": "code", "execution_count": 55, "id": "wooden-negotiation", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# TODO: plot population vs total_rooms\n", "# Hint: Use a scatter plot.\n", "housing.plot(kind=\"scatter\", x=\"population\", y=\"total_rooms\", alpha=0.2)" ] }, { "cell_type": "markdown", "id": "occupational-biology", "metadata": {}, "source": [ "Take a look at the following code. \n", "\n", "**Q: What pattern does the following code show?** Hint: [Look at this map.](https://www.google.com/maps/place/California/@36.4998513,-121.7064629,6.55z/data=!4m5!3m4!1s0x808fb9fe5f285e3d:0x8b5109a227086f55!8m2!3d36.778261!4d-119.4179324)" ] }, { "cell_type": "code", "execution_count": 35, "id": "offshore-answer", "metadata": {}, "outputs": [], "source": [ "# TODO by TAs.\n", "housing.plot(kind=\"scatter\", x=\"longitude\", y=\"latitude\", alpha=0.2, s=housing[\"population\"]/100, label=\"population\", figsize=(10,7))" ] }, { "cell_type": "markdown", "id": "touched-smith", "metadata": {}, "source": [ "We are now done with data exploration. We know what the data looks like, and what preparation we need to do before moving on to training." ] }, { "cell_type": "markdown", "id": "packed-export", "metadata": {}, "source": [ "## Data Preparation" ] }, { "cell_type": "code", "execution_count": 36, "id": "restricted-remedy", "metadata": {}, "outputs": [], "source": [ "# First separate features from target variables.\n", "features = housing.drop(\"house_value_class\", axis=1)\n", "target = housing[\"house_value_class\"]" ] }, { "cell_type": "markdown", "id": "multiple-batman", "metadata": {}, "source": [ "We need the following transformation to make our data work with ML algorithms:\n", "1. One hot encoding of the categorical features. \n", "2. Median imputation on numerical features.\n", "3. Standardize numerical features.\n", "4. Encode class labels into ordinals (0, 1, 2, ...). This is what the ML libraries we'll use expect.\n", "\n", "`sklearn` has builtin functions for all of these. It also has convenience functions to put them all together.\n", "\n", "----\n", "\n", "One hot encoding works as follows." ] }, { "cell_type": "code", "execution_count": 37, "id": "undefined-graph", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[1., 0., 0., 0., 0.],\n", " [0., 1., 0., 0., 0.],\n", " [1., 0., 0., 0., 0.],\n", " ...,\n", " [0., 1., 0., 0., 0.],\n", " [0., 1., 0., 0., 0.],\n", " [0., 1., 0., 0., 0.]])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# One hot encoding\n", "from sklearn.preprocessing import OneHotEncoder\n", "\n", "# Get columns to transform.\n", "categorical_col_names = ['ocean_proximity'] # stored as a separate variable for later.\n", "categorical = features[categorical_col_names]\n", "\n", "# Do one hot encoding.\n", "encoder = OneHotEncoder()\n", "categorical_one_hot = encoder.fit_transform(categorical)\n", "categorical_one_hot.toarray()" ] }, { "cell_type": "markdown", "id": "professional-cooking", "metadata": {}, "source": [ "As for imputation, `sklearn` has a [variety of implementations](https://scikit-learn.org/stable/modules/classes.html#module-sklearn.impute) (corresponding to the techniques we described in class). We will stick to simple median imputation, but feel free to try something different in your custom project." ] }, { "cell_type": "code", "execution_count": 38, "id": "growing-penny", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Num missing before imputation: 167\n", "Num missing before imputation: 0\n" ] } ], "source": [ "from sklearn.impute import SimpleImputer\n", "\n", "# Get columns to transform.\n", "numerical_col_names = [c for c in features.columns if c != 'ocean_proximity'] # stored as a separate variable for later.\n", "numerical = features[numerical_col_names]\n", "\n", "# Print missing count\n", "print(\"Num missing before imputation:\", np.count_nonzero(np.isnan(numerical)))\n", "\n", "# Do transformation.\n", "imputer = SimpleImputer(strategy=\"median\")\n", "imputed_numerical = imputer.fit_transform(numerical)\n", "\n", "# Print missing count. Should be 0.\n", "print(\"Num missing after imputation:\", np.count_nonzero(np.isnan(imputed_numerical)))" ] }, { "cell_type": "markdown", "id": "economic-curve", "metadata": {}, "source": [ "Take a look at the documentation for [sklearn.preprocessing.StandardScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) and use it to normalize numerical columns in `imputed_numerical`." ] }, { "cell_type": "code", "execution_count": 39, "id": "mineral-objective", "metadata": {}, "outputs": [], "source": [ "# TODO: Do scaling (~2 mins)\n", "from sklearn.preprocessing import StandardScaler\n", "scaler = StandardScaler()\n", "numerical_scaled = scaler.fit_transform(imputed_numerical)\n", "numerical_scaled" ] }, { "cell_type": "markdown", "id": "rocky-arabic", "metadata": {}, "source": [ "`sklearn` has a simple API to chain all of these transformation together. Take a look at the documentation for [sklearn.pipeline.Pipeline](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html) and [sklearn.compose.ColumnTransformer](https://scikit-learn.org/stable/modules/generated/sklearn.compose.ColumnTransformer.html)." ] }, { "cell_type": "code", "execution_count": 52, "id": "developing-texture", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123456789101112
01.00.00.00.00.0-1.0261840.492694-0.367613-0.0244500.4779361.6044750.527124-0.891248
10.01.00.00.00.0-1.2551682.6634301.8565940.6284250.6802980.2649150.537584-0.854774
21.00.00.00.00.00.850486-0.8546590.426747-0.389292-0.1386730.259610-0.155387-0.552237
31.00.00.00.00.00.850486-0.8967630.585619-1.121719-1.181432-1.079066-1.211839-0.263220
40.01.00.00.00.0-0.8469801.161692-1.4002800.2370660.6088760.5991420.684023-0.748915
..........................................
165070.01.00.00.00.01.104359-0.779806-0.288177-0.113603-0.529112-0.422107-0.4874892.286572
165081.00.00.00.00.00.671281-0.6955961.856594-0.574456-0.636245-0.613094-0.683613-0.071730
165090.01.00.00.00.0-1.1406760.969882-1.2414083.1896341.9182772.6177662.3288461.470198
165100.01.00.00.00.00.890309-0.489751-1.7974593.4831533.1562564.1863343.3486890.001585
165110.01.00.00.00.0-0.7075981.423678-1.6385881.0371580.4898400.5098380.5820380.819636
\n", "

16512 rows × 13 columns

\n", "
" ], "text/plain": [ " 0 1 2 3 4 5 6 7 8 \\\n", "0 1.0 0.0 0.0 0.0 0.0 -1.026184 0.492694 -0.367613 -0.024450 \n", "1 0.0 1.0 0.0 0.0 0.0 -1.255168 2.663430 1.856594 0.628425 \n", "2 1.0 0.0 0.0 0.0 0.0 0.850486 -0.854659 0.426747 -0.389292 \n", "3 1.0 0.0 0.0 0.0 0.0 0.850486 -0.896763 0.585619 -1.121719 \n", "4 0.0 1.0 0.0 0.0 0.0 -0.846980 1.161692 -1.400280 0.237066 \n", "... ... ... ... ... ... ... ... ... ... \n", "16507 0.0 1.0 0.0 0.0 0.0 1.104359 -0.779806 -0.288177 -0.113603 \n", "16508 1.0 0.0 0.0 0.0 0.0 0.671281 -0.695596 1.856594 -0.574456 \n", "16509 0.0 1.0 0.0 0.0 0.0 -1.140676 0.969882 -1.241408 3.189634 \n", "16510 0.0 1.0 0.0 0.0 0.0 0.890309 -0.489751 -1.797459 3.483153 \n", "16511 0.0 1.0 0.0 0.0 0.0 -0.707598 1.423678 -1.638588 1.037158 \n", "\n", " 9 10 11 12 \n", "0 0.477936 1.604475 0.527124 -0.891248 \n", "1 0.680298 0.264915 0.537584 -0.854774 \n", "2 -0.138673 0.259610 -0.155387 -0.552237 \n", "3 -1.181432 -1.079066 -1.211839 -0.263220 \n", "4 0.608876 0.599142 0.684023 -0.748915 \n", "... ... ... ... ... \n", "16507 -0.529112 -0.422107 -0.487489 2.286572 \n", "16508 -0.636245 -0.613094 -0.683613 -0.071730 \n", "16509 1.918277 2.617766 2.328846 1.470198 \n", "16510 3.156256 4.186334 3.348689 0.001585 \n", "16511 0.489840 0.509838 0.582038 0.819636 \n", "\n", "[16512 rows x 13 columns]" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.compose import ColumnTransformer\n", "from sklearn.pipeline import Pipeline\n", "\n", "\n", "# Categorical Transformations\n", "categorical_pipeline = Pipeline([\n", " (\"one_hot_encoder\", OneHotEncoder()),\n", "])\n", "\n", "# Numerical Transformations\n", "numerical_pipeline = Pipeline([\n", " (\"imputer\", SimpleImputer(strategy=\"median\")),\n", " (\"scaler\", StandardScaler())\n", "])\n", "\n", "\n", "# Full transformation\n", "feature_transformer = ColumnTransformer([\n", " # Categorical\n", " (\"categorical\", categorical_pipeline, categorical_col_names),\n", " # Numerical\n", " (\"numerical\", numerical_pipeline, numerical_col_names),\n", "])\n", "\n", "features_prepped = feature_transformer.fit_transform(features)\n", "pd.DataFrame(features_prepped)" ] }, { "cell_type": "markdown", "id": "acceptable-narrative", "metadata": {}, "source": [ "Finally, we need to encode the label (LOW=i, MEDIUM=j, HIGH=k) to satisfy `sklearn`." ] }, { "cell_type": "code", "execution_count": 17, "id": "governmental-friendship", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 0])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.preprocessing import LabelEncoder\n", "\n", "label_encoder = LabelEncoder()\n", "\n", "target_prepped = label_encoder.fit_transform(target)\n", "\n", "pd.Series(target_prepped).unique()" ] }, { "cell_type": "markdown", "id": "moving-hours", "metadata": {}, "source": [ "The data is now ready for ML modeling." ] }, { "cell_type": "markdown", "id": "static-university", "metadata": {}, "source": [ "## Training and Validation\n", "We'll now have to train and validate a few models to find the best performing one.\n", "We start with the simple kind of model: linear classifier. We will then give a few minutes to try out gradient boosted trees.\n", "\n", "Training a model is simple with `sklearn`." ] }, { "cell_type": "code", "execution_count": 18, "id": "funded-mother", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "SGDClassifier()" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from sklearn.linear_model import SGDClassifier\n", "\n", "# Train model\n", "lin_sgd = SGDClassifier(loss='hinge')\n", "\n", "lin_sgd.fit(features_prepped, target_prepped)" ] }, { "cell_type": "markdown", "id": "beneficial-whale", "metadata": {}, "source": [ "Performing predictions is equally easy." ] }, { "cell_type": "code", "execution_count": 19, "id": "cardiac-indication", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['MEDIUM', 'MEDIUM', 'LOW', 'LOW', 'MEDIUM', 'LOW', 'LOW', 'MEDIUM',\n", " 'MEDIUM', 'MEDIUM'], dtype=object)" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get some random input\n", "sample = housing.sample(n=10, random_state=1)\n", "# Tranform input\n", "sample_prepped = feature_transformer.transform(sample)\n", "# Make prediction\n", "prediction = lin_sgd.predict(sample_prepped)\n", "# Decode prediction\n", "label_encoder.inverse_transform(prediction)" ] }, { "cell_type": "markdown", "id": "contrary-enterprise", "metadata": {}, "source": [ "Let's validate the efficacy of the model. `sklearn` provides builtin cross-validation. ****" ] }, { "cell_type": "code", "execution_count": 20, "id": "worldwide-garden", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 76.65% (1.27%)\n" ] } ], "source": [ "from sklearn.model_selection import cross_val_score, KFold\n", "\n", "# Do cross validation\n", "# The cv parameter is the number of cross-validation splits.\n", "lin_sgd = SGDClassifier(loss='hinge')\n", "kfold = KFold(n_splits=10, shuffle=True, random_state=37)\n", "scores = cross_val_score(lin_sgd, features_prepped, target_prepped, cv=kfold)\n", "print(\"Accuracy: %.2f%% (%.2f%%)\" % (scores.mean()*100, scores.std()*100))" ] }, { "cell_type": "markdown", "id": "unnecessary-specific", "metadata": {}, "source": [ "We get a validation accuracy of ~$76\\%$. This may or may not be ok depending on your application. Let's try `xgboost.XGBClassifier` and see if it does better." ] }, { "cell_type": "code", "execution_count": 25, "id": "traditional-latter", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 85.73% (0.82%)\n" ] } ], "source": [ "from xgboost import XGBClassifier\n", "\n", "# You'll need at least these flags \n", "xgb_cls = XGBClassifier(eval_metric='mlogloss', use_label_encoder=False)\n", "\n", "# TODO: Add fitting and validation. Validation can be somewhat slow.\n", "kfold = KFold(n_splits=10, shuffle=True, random_state=37)\n", "scores = cross_val_score(xgb_cls, features_prepped, target_prepped, cv=kfold)\n", "print(\"Accuracy: %.2f%% (%.2f%%)\" % (scores.mean()*100, scores.std()*100))\n" ] }, { "cell_type": "markdown", "id": "center-worth", "metadata": {}, "source": [ "You should have obtained an accuracy better than before. \n", "**Q: Why do think `xgboost` performs better than linear SGD?**\n", "\n", "---\n", "\n", "**Given a model, how should we tune it to improve training performance?**" ] }, { "cell_type": "markdown", "id": "rental-indianapolis", "metadata": {}, "source": [ "## Testing\n", "We can now test our model to see how well it performs in the \"real-world\". **Q: Why can't we compare our models in the testing phase?**.\n", "\n", "Fill-in the following code." ] }, { "cell_type": "code", "execution_count": 22, "id": "legislative-coupon", "metadata": {}, "outputs": [], "source": [ "from sklearn.metrics import accuracy_score\n", "\n", "# Train\n", "xgb_cls = XGBClassifier(eval_metric='mlogloss', use_label_encoder=False)\n", "xgb_cls.fit(features_prepped, target_prepped)\n", "\n", "# TODO: Implementing testing code here.\n", "test_target = test_set['house_value_class']\n", "test_features = test_set.drop('house_value_class', axis=1)\n", "\n", "test_target_prepped = label_encoder.transform(test_target)\n", "test_features_prepped = feature_transformer.transform(test_features)\n", "\n", "test_predictions = xgb_cls.predict(test_features_prepped)\n", "accuracy = accuracy_score(test_target_prepped, test_predictions)" ] }, { "cell_type": "code", "execution_count": 23, "id": "connected-roller", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.8604651162790697" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "accuracy" ] }, { "cell_type": "markdown", "id": "monetary-forge", "metadata": {}, "source": [ "Thanks to k-fold cross validation, you should see that your test error is fairly similar to your validation error. This allows us to predict performance on unseen data, as long its distribution is reasonably similar to the training data." ] }, { "cell_type": "code", "execution_count": null, "id": "round-player", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.10" } }, "nbformat": 4, "nbformat_minor": 5 }