Hws/hw9.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "# Initialize Otter\n",
    "import otter\n",
    "grader = otter.Notebook(\"hw9.ipynb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e0f9b2de18190d9d",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# Homework 9: Predicting Housing Prices in Cook County\n",
    "\n",
    "## Due Date: Thursday, October 28th, 11:59 PM\n",
    "\n",
    "### Collaboration Policy\n",
    "\n",
    "Data science is a collaborative activity. While you may talk with others about the homework, we ask that you **write your solutions individually**. If you do discuss the assignments with others please **include their names** in the collaborators cell below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Collaborators:** *list names here*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "In Homework 8, you performed some basic exploratory data analysis (EDA), laying out the thought process that leads to certain modeling decisions. Then, you added a few new features to the dataset, cleaning the data as well in the process.\n",
    "\n",
    "In this homework, you will specify and fit a linear model to a few features of the housing data to predict housing prices. Next, we will analyze the error of the model and brainstorm ways to improve the model's performance. Finally, we'll delve deeper into the implications of predictive modeling within the Cook County Assessor's Office (CCAO) case study, especially because statistical modeling is how the CCAO valuates properties. Given the history of racial discrimination in housing policy and property taxation in Cook County, consider the impacts of your modeling results as you work through this assignment - and think about what fairness might mean to property owners in Cook County.\n",
    "\n",
    "After this homework, you should be comfortable with:\n",
    "- Implementing a data processing pipeline using `pandas`\n",
    "- Using `scikit-learn` to build and fit linear models\n",
    "\n",
    "## Score Breakdown\n",
    "\n",
    "Question | Points\n",
    "----|----\n",
    "1 | 2\n",
    "2 | 2\n",
    "3 | 3\n",
    "4 | 2\n",
    "5 | 2\n",
    "6 | 1\n",
    "7 | 2\n",
    "8 | 6\n",
    "9 | 2\n",
    "10 | 1\n",
    "11 | 2\n",
    "Total | 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-62cfd21463535cac",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import pandas as pd\n",
    "from pandas.api.types import CategoricalDtype\n",
    "\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import zipfile\n",
    "import os\n",
    "\n",
    "from ds100_utils import run_linear_regression_test\n",
    "\n",
    "# Plot settings\n",
    "plt.rcParams['figure.figsize'] = (12, 9)\n",
    "plt.rcParams['font.size'] = 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load the training and test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "with zipfile.ZipFile('cook_county_data.zip') as item:\n",
    "    item.extractall()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-e8fea30adc9d489b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "training_data = pd.read_csv(\"cook_county_train.csv\", index_col='Unnamed: 0')\n",
    "test_data = pd.read_csv(\"cook_county_test.csv\", index_col='Unnamed: 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-9d6d509b6e854e10",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "As a good sanity check, we should at least verify that the data shape matches the description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-c841a2de55691502",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# 204792 observations and 62 features in training data\n",
    "assert training_data.shape == (204792, 62)\n",
    "# 68264 observations and 61 features in test data\n",
    "assert test_data.shape == (68264, 61)\n",
    "# Sale Price is provided in the training data\n",
    "assert 'Sale Price' in training_data.columns.values\n",
    "# Sale Price is hidden in the test data\n",
    "assert 'Sale Price' not in test_data.columns.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-ce9acc2f62c96e59",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Let's remind ourselves of the data available to us in the Cook County dataset. Remember, a more detailed description of each variable is included in `codebook.txt`, which is in the same directory as this notebook). **If you did not attempt Homework 8,** you should take some time to familiarize yourself with the codebook before moving forward."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-4e60a7a0cda5eecf",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['PIN', 'Property Class', 'Neighborhood Code', 'Land Square Feet',\n",
       "       'Town Code', 'Apartments', 'Wall Material', 'Roof Material',\n",
       "       'Basement', 'Basement Finish', 'Central Heating', 'Other Heating',\n",
       "       'Central Air', 'Fireplaces', 'Attic Type', 'Attic Finish',\n",
       "       'Design Plan', 'Cathedral Ceiling', 'Construction Quality',\n",
       "       'Site Desirability', 'Garage 1 Size', 'Garage 1 Material',\n",
       "       'Garage 1 Attachment', 'Garage 1 Area', 'Garage 2 Size',\n",
       "       'Garage 2 Material', 'Garage 2 Attachment', 'Garage 2 Area',\n",
       "       'Porch', 'Other Improvements', 'Building Square Feet',\n",
       "       'Repair Condition', 'Multi Code', 'Number of Commercial Units',\n",
       "       'Estimate (Land)', 'Estimate (Building)', 'Deed No.', 'Sale Price',\n",
       "       'Longitude', 'Latitude', 'Census Tract',\n",
       "       'Multi Property Indicator', 'Modeling Group', 'Age', 'Use',\n",
       "       \"O'Hare Noise\", 'Floodplain', 'Road Proximity', 'Sale Year',\n",
       "       'Sale Quarter', 'Sale Half-Year', 'Sale Quarter of Year',\n",
       "       'Sale Month of Year', 'Sale Half of Year', 'Most Recent Sale',\n",
       "       'Age Decade', 'Pure Market Filter', 'Garage Indicator',\n",
       "       'Neigborhood Code (mapping)', 'Town and Neighborhood',\n",
       "       'Description', 'Lot Size'], dtype=object)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training_data.columns.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Question 1\n",
    "\n",
    "Now, let's split the data set into a training set and test set. We will use the training set to fit our model's parameters, and we will use the test set to estimate how well our model will perform on unseen data drawn from the same distribution. If we used all the data to fit our model, we would not have a way to estimate model performance on unseen data.\n",
    "\n",
    "\"Don't we already have a test set in `cook_county_test.csv`?\" you might wonder. The sale prices for `cook_county_test.csv` aren't provided, so we're constructing our own test set for which we know the outputs.\n",
    "\n",
    "In the cell below, complete the function `train_test_split` that splits `data` into two smaller DataFrames named `train` and `test`. Let `train` contain 80% of the data, and let `test` contain the remaining 20% of the data. \n",
    "\n",
    "To do this, first create two NumPy arrays named `train_indices` and `test_indices`. `train_indices` should contain a *random* 80% of the indices in `full_data`, and `test_indices` should contain the remaining 20% of the indices. Then, use these arrays to index into `full_data` to create your final `train` and `test` DataFrames.\n",
    "\n",
    "*The provided tests check that you not only answered correctly, but ended up with the exact same train/test split as our reference implementation. Later testing is easier this way.*\n",
    "\n",
    "**Note**: You should not be importing any additional libraries for this question. \n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q1\n",
    "points: 2\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This makes the train-test split in this section reproducible across different runs \n",
    "# of the notebook. You do not need this line to run train_test_split in general\n",
    "\n",
    "# DO NOT CHANGE THIS LINE\n",
    "np.random.seed(1337)\n",
    "# DO NOT CHANGE THIS LINE\n",
    "\n",
    "def train_test_split(data):\n",
    "    data_len = data.shape[0]\n",
    "    shuffled_indices = np.random.permutation(data_len)\n",
    "    pivot = int(data_len * 0.8)\n",
    "    train_indices, test_indices = shuffled_indices[:pivot], shuffled_indices[pivot:]\n",
    "    return data.iloc[train_indices, :], data.iloc[test_indices, :]\n",
    "                                     \n",
    "train, test = train_test_split(training_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong><pre style='display: inline;'>q1</pre></strong> passed!</p>"
      ],
      "text/plain": [
       "q1 results: All test cases passed!"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check(\"q1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's fit our updated linear regression model using the ordinary least squares estimator! We will start you off with something simple by using only 2 features: the **number of bedrooms** in the household and the **log-transformed total area covered by the building** (in square feet). \n",
    "\n",
    "Consider the following expression for our 1st linear model that contains one of the features:\n",
    "\n",
    "$$\n",
    "\\text{Log Sale Price} = \\theta_0 + \\theta_1 \\cdot (\\text{Bedrooms})\n",
    "$$\n",
    "\n",
    "In parallel, we will also consider a 2nd model that contains both features:\n",
    "\n",
    "$$\n",
    "\\text{Log Sale Price} = \\theta_0 + \\theta_1 \\cdot (\\text{Bedrooms}) + \\theta_2 \\cdot (\\text{Log Building Square Feet})\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "## Question 2\n",
    "\n",
    "**Without running any calculation or code**, complete the following statement by filling in the blank with one of the  comparators below:\n",
    "\n",
    "$$\\ge$$\n",
    "$$\\le$$\n",
    "$$=$$\n",
    "\n",
    "Suppose we quantify the loss on our linear models using MSE (Mean Squared Error). Consider the training loss of the 1st model and the training loss of the 2nd model. We are guaranteed that:\n",
    "\n",
    "$$\n",
    "\\text{Training Loss of the 1st Model}  \\_\\_\\_\\_\\_  \\text{Training Loss of the 2nd Model}\n",
    "$$\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q2\n",
    "points: 2\n",
    "manual: True\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Type your answer here, replacing this text._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "\n",
    "\n",
    "## Question 3\n",
    "\n",
    "In Homework 8, you wrote a few functions that added features to the dataset. Instead of manually calling each function to add these features to the dataset, it is best practice to encapsulate all of this feature engineering into one \"pipeline\" function. Defining and using a pipeline reduces all the feature engineering to just one function call and ensures that the same transformations are applied to all data. In this question, we will build a pipeline with the function `process_data_gm`. \n",
    "\n",
    "Take a look at the following function `process_data_gm`, which takes in a dataframe `data`, a list `pipeline_functions` containing 3-element tuples `(function, arguments, keyword_arguments)` that will be called on `data` in the pipeline, and the label `prediction_col` that represents the column of our target variable (`Sale Price` in this case). It returns two dataframes: `X`, which is our design matrix, and `y` which is the vector containing the observed data. Take a look at [pd.DataFrame.pipe](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.pipe.html); you can use this function with each of the tuples passed in through `pipeline_functions`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from feature_func import *    # imports functions from HW7\n",
    "\n",
    "def process_data_gm(data, pipeline_functions, prediction_col):\n",
    "    \"\"\"Process the data for a guided model.\"\"\"\n",
    "    for function, arguments, keyword_arguments in pipeline_functions:\n",
    "        if keyword_arguments and (not arguments):\n",
    "            data = data.pipe(function, **keyword_arguments)\n",
    "        elif (not keyword_arguments) and (arguments):\n",
    "            data = data.pipe(function, *arguments)\n",
    "        else:\n",
    "            data = data.pipe(function)\n",
    "    X = data.drop(columns=[prediction_col]).to_numpy()\n",
    "    y = data.loc[:, prediction_col].to_numpy()\n",
    "    return X, y\n",
    "\n",
    "def select_columns(data, *columns):\n",
    "    \"\"\"Select only columns passed as arguments.\"\"\"\n",
    "    return data.loc[:, columns]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reload the data\n",
    "full_data = pd.read_csv(\"cook_county_train.csv\")\n",
    "\n",
    "# Process the data using the pipeline for the first model\n",
    "np.random.seed(1337)\n",
    "train_m1, test_m1 = train_test_split(full_data)\n",
    "\n",
    "# A custom function that applies log transformation\n",
    "def log_transform(data, col):\n",
    "    data['Log ' + col] = np.log(data[col])\n",
    "    return data\n",
    "\n",
    "m1_pipelines = [\n",
    "    (remove_outliers, None, {\n",
    "        'variable': 'Sale Price',\n",
    "        'lower': 499,\n",
    "    }),\n",
    "    (log_transform, None, {'col': 'Sale Price'}),\n",
    "    (add_total_bedrooms, None, None),\n",
    "    (select_columns, ['Log Sale Price', 'Bedrooms'], None)\n",
    "]\n",
    "\n",
    "\n",
    "X_train_m1, y_train_m1 = process_data_gm(train_m1, m1_pipelines, 'Log Sale Price')\n",
    "X_test_m1, y_test_m1 = process_data_gm(test_m1, m1_pipelines, 'Log Sale Price')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "It is time to prepare the training and validation data for the two models we proposed above. Use the following 3 cells to reload a fresh dataset from scratch and run them through the following preprocessing steps for each model:\n",
    "\n",
    "- Perform a `train_test_split` on the original dataset. Let 80% of the set be training data and 20% of the set be validation data. **Even though we are splitting our dataset into training and validation sets, this question will refer to the validation set as the test set.**\n",
    "- For both the training and validation set,\n",
    "    1. Remove outliers in `Sale Price` by so that we are considering households with a price that is strictly greater than 499 dollars (i.e., greater than or equal to 500 dollars). \n",
    "    2. Apply log transformations to `Sale Price` and the `Building Square Feet` columns to create 2 new columns `Log Sale Price` and `Log Building Square Feet`.\n",
    "    3. Extract the total number of bedrooms into a new column `Bedrooms` from the `Description` column.\n",
    "    4. Select the columns `Log Sale Price` and `Bedrooms` (and `Log Building Square Feet` as well if this is the 2nd model).\n",
    "    5. Return the design matrix $X$ and the observed vector $y$. **Your design matrix and observed vector should either be numpy arrays or pandas dataframes**.\n",
    "    \n",
    "\n",
    "Assign the final training data and validation data for both models to the following set of variables:\n",
    "\n",
    "- 1st Model: `X_train_m1`, `y_train_m1`, `X_test_m1`, `y_test_m1`\n",
    "- 2nd Model: `X_train_m2`, `y_train_m2`, `X_test_m2`, `y_test_m2`\n",
    "\n",
    "**We have automatically imported staff implementations of the functions you wrote in Homework 8.** These functions are `remove_outliers`, `add_total_bedrooms`, `find_expensive_neighborhoods`, `add_in_expensive_neighborhood`, and `ohe_roof_material`. You are welcome to copy over your own implementations if you like.\n",
    "\n",
    "**Hint:** We have processed the data for the first model for you to use as an example.\n",
    "\n",
    "**Note**: Do not change the line `np.random.seed(1337)` as it ensures we are partitioning the dataset exactly the same way for both models (otherwise their performance isn't directly comparable).\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q3\n",
    "points: 3\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This property, sold on 07/23/2013, is a one-story with partially livable attics houeshold located at 2012 DOBSON ST.It has a total of 5 rooms, 3 of which are bedrooms, and 1.5 of which are bathrooms.'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_data.loc[3, 'Description']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT CHANGE THIS LINE\n",
    "np.random.seed(1337)\n",
    "# DO NOT CHANGE THIS LINE\n",
    "\n",
    "train_m2, test_m2 = train_test_split(full_data)\n",
    "\n",
    "\n",
    "\n",
    "m2_pipelines = [\n",
    "    (remove_outliers, None, {\n",
    "        'variable': 'Sale Price',\n",
    "        'lower': 499,\n",
    "    }),\n",
    "    (log_transform, None, {'col': 'Sale Price'}),\n",
    "    (log_transform, None, {'col': 'Building Square Feet'}),\n",
    "    (add_total_bedrooms, None, None),\n",
    "    (select_columns, ['Log Sale Price', 'Log Building Square Feet', 'Bedrooms'], None)\n",
    "]\n",
    "\n",
    "\n",
    "X_train_m2, y_train_m2 = process_data_gm(train_m2, m2_pipelines, 'Log Sale Price')\n",
    "X_test_m2, y_test_m2 = process_data_gm(test_m2, m2_pipelines, 'Log Sale Price')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong><pre style='display: inline;'>q3</pre></strong> passed!</p>"
      ],
      "text/plain": [
       "q3 results: All test cases passed!"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check(\"q3\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 4\n",
    "\n",
    "Finally, let's do some regression!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first initialize a [`sklearn.linear_model.LinearRegression`](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html) object for both of our models. We set the `fit_intercept = True` to ensure that the linear model has a non-zero intercept."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import linear_model as lm\n",
    "\n",
    "linear_model_m1 = lm.LinearRegression(fit_intercept=True)\n",
    "linear_model_m2 = lm.LinearRegression(fit_intercept=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Now it's time to fit our linear regression model. Use the cell below to fit both models, and then use it to compute the fitted values of `Sale Price` over the training data, and the predicted values of `Sale Price` for the testing data.\n",
    "\n",
    "Assign the predicted values from both of your models on the training and testing set to the following variables:\n",
    "\n",
    "- 1st Model: prediction on training set: `y_fitted_m1`, prediction on testing set: `y_predicted_m1`\n",
    "- 2nd Model: prediction on training set: `y_fitted_m2`, prediction on testing set: `y_predicted_m2`\n",
    "\n",
    "**Note**: To make sure you understand how to find the predicted value for both the training and testing data set, there won't be any hidden tests for this part.\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q4\n",
    "points: 2\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Fit the 1st model\n",
    "linear_model_m1.fit(X_train_m1, y_train_m1)\n",
    "# Compute the fitted and predicted values of Sale Price for 1st model\n",
    "y_fitted_m1 = linear_model_m1.predict(X_train_m1)\n",
    "y_predicted_m1 = linear_model_m1.predict(X_test_m1)\n",
    "\n",
    "# Fit the 2nd model\n",
    "linear_model_m2.fit(X_train_m2, y_train_m2)\n",
    "# Compute the fitted and predicted values of Sale Price for 1st model\n",
    "y_fitted_m2 = linear_model_m2.predict(X_train_m2)\n",
    "y_predicted_m2 = linear_model_m2.predict(X_test_m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong><pre style='display: inline;'>q4</pre></strong> passed!</p>"
      ],
      "text/plain": [
       "q4 results: All test cases passed!"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check(\"q4\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question 5\n",
    "\n",
    "Let's compare the performance of our two regression models using the Root Mean Squared Error function that we created in Homework 6.\n",
    "\n",
    "$$RMSE = \\sqrt{\\dfrac{\\sum_{\\text{houses in test set}}(\\text{actual price for house} - \\text{predicted price for house})^2}{\\text{number of of houses}}}$$\n",
    "\n",
    "The function is provided below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rmse(predicted, actual):\n",
    "    \"\"\"\n",
    "    Calculates RMSE from actual and predicted values\n",
    "    Input:\n",
    "      predicted (1D array): vector of predicted/fitted values\n",
    "      actual (1D array): vector of actual values\n",
    "    Output:\n",
    "      a float, the root-mean square error\n",
    "    \"\"\"\n",
    "    return np.sqrt(np.mean((actual - predicted)**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Now use your `rmse` function to calculate the training error and test error for both models in the cell below.\n",
    "\n",
    "Assign the error from both of your models to the following variables:\n",
    "\n",
    "- 1st model: `training_error_m1`, `test_error_m1`\n",
    "- 2nd model: `training_error_m2`, `test_error_m2`\n",
    "\n",
    "Since the target variable we are working with is log-transformed, it can also be beneficial to transform it back to its original form so we will have more context on how our model is performing when compared to actual housing prices.\n",
    "\n",
    "Assign the error on the \"de-log-transformed\" sale price from both of your models to the following variables:\n",
    "\n",
    "- 1st model: `training_error_m1_delog`, `test_error_m1_delog`\n",
    "- 2nd model: `training_error_m2_delog`, `test_error_m2_delog`\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q5\n",
    "points: 2\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st Model\n",
      "Training RMSE: 0.9025651719699076\n",
      "Test RMSE: 0.9068644732045896\n",
      "\n",
      "1st Model (no log transform)\n",
      "Training RMSE: 2.4659205152646577\n",
      "Test RMSE: 2.47654507310253\n",
      "\n",
      "2nd Model\n",
      "Training RMSE: 0.8042009333446841\n",
      "Test RMSE: 0.8113963052434995\n",
      "\n",
      "2nd Model (no log transform)\n",
      "Training RMSE: 2.2349099431133252\n",
      "Test RMSE: 2.251048944742962\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training and test errors for the 1st model\n",
    "training_error_m1 = rmse(y_fitted_m1, y_train_m1)\n",
    "test_error_m1 = rmse(y_predicted_m1, y_test_m1)\n",
    "\n",
    "# Training and test errors for the 1st model (in its original values before the log transform)\n",
    "training_error_m1_delog = np.exp(training_error_m1)\n",
    "test_error_m1_delog = np.exp(test_error_m1)\n",
    "\n",
    "\n",
    "# Training and test errors for the 2nd model\n",
    "training_error_m2 = rmse(y_fitted_m2, y_train_m2)\n",
    "test_error_m2 = rmse(y_predicted_m2, y_test_m2)\n",
    "\n",
    "\n",
    "# Training and test errors for the 2nd model (in its original values before the log transform)\n",
    "training_error_m2_delog = np.exp(training_error_m2)\n",
    "test_error_m2_delog = np.exp(test_error_m2)\n",
    "\n",
    "print(\"1st Model\\nTraining RMSE: {}\\nTest RMSE: {}\\n\".format(training_error_m1, test_error_m1))\n",
    "print(\"1st Model (no log transform)\\nTraining RMSE: {}\\nTest RMSE: {}\\n\".format(training_error_m1_delog, test_error_m1_delog))\n",
    "print(\"2nd Model\\nTraining RMSE: {}\\nTest RMSE: {}\\n\".format(training_error_m2, test_error_m2))\n",
    "print(\"2nd Model (no log transform)\\nTraining RMSE: {}\\nTest RMSE: {}\\n\".format(training_error_m2_delog, test_error_m2_delog))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong><pre style='display: inline;'>q5</pre></strong> passed!</p>"
      ],
      "text/plain": [
       "q5 results: All test cases passed!"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check(\"q5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "## Question 6\n",
    "\n",
    "Let's compare the actual parameters ($\\theta_0$ and $\\theta_1$) from both of our models. As a quick reminder,\n",
    "\n",
    "for the 1st model,\n",
    "$$\n",
    "\\text{Log Sale Price} = \\theta_0 + \\theta_1 \\cdot (\\text{Bedrooms})\n",
    "$$\n",
    "\n",
    "for the 2nd model,\n",
    "$$\n",
    "\\text{Log Sale Price} = \\theta_0 + \\theta_1 \\cdot (\\text{Bedrooms}) + \\theta_2 \\cdot (\\text{Log Building Square Feet})\n",
    "$$\n",
    "\n",
    "Run the following cell and compare the values of $\\theta_1$ from both models. Why does $\\theta_1$ change from positive to negative when we introduce an additional feature in our 2nd model? \n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q6\n",
    "points: 1\n",
    "manual: True\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1st Model\n",
      "θ0: 10.571725401040124\n",
      "θ1: 0.49691974631413155\n",
      "2nd Model\n",
      "θ0: 1.9339633173823962\n",
      "θ1: 1.4170991378689604\n",
      "θ2: -0.030647249803553964\n"
     ]
    }
   ],
   "source": [
    "# Parameters from 1st model\n",
    "theta0_m1 = linear_model_m1.intercept_\n",
    "theta1_m1 = linear_model_m1.coef_[0]\n",
    "\n",
    "# Parameters from 2nd model\n",
    "theta0_m2 = linear_model_m2.intercept_\n",
    "theta1_m2, theta2_m2 = linear_model_m2.coef_\n",
    "\n",
    "print(\"1st Model\\nθ0: {}\\nθ1: {}\".format(theta0_m1, theta1_m1))\n",
    "print(\"2nd Model\\nθ0: {}\\nθ1: {}\\nθ2: {}\".format(theta0_m2, theta1_m2, theta2_m2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Type your answer here, replacing this text._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-a359da2dda38fcdd",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "## Question 7\n",
    "\n",
    "Another way of understanding the performance (and appropriateness) of a model is through a plot of the model predictions versus the observations.\n",
    "\n",
    "In the cell below, use `plt.scatter` to plot the predicted `Log Sale Price` from **only the 2nd model** against the original `Log Sale Price` for the test data. You should also ensure that the dot size and opacity in the scatter plot are set appropriately to reduce the impact of overplotting.\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q7\n",
    "points: 2\n",
    "manual: True\n",
    "format: image\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "nbgrader": {
     "grade": false,
     "grade_id": "cell-4d79f42d60b94fca",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(x = y_predicted_m2, y = y_test_m2, s = 3, alpha = 0.3);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "\n",
    "\n",
    "As you can see, our simple model has already got off to a good start, but there is certainly still a lot of room for improvement to be made -- one simple reason is we have been only utilizing 1 or 2 features (out of a total of 70+) so far! Can you engineer and incoporate more features to improve the model's accuracy? We won't be asking you to provide your answers here, but this would be important going into the next part (also last part wohoo!) of this assignment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Question 8\n",
    "\n",
    "It is time to build your own model!\n",
    "\n",
    "Just as in the guided model from the previous question, you should encapsulate as much of your workflow into functions as possible. Your job is to select better features and define your own feature engineering pipeline inside the function `process_data_fm` in the following cell. **You must not change the parameters inside `process_data_fm`**.\n",
    "\n",
    "To evaluate your model, we will start by defining a linear regression model called `final_model`. Then, we will process training data using your `process_data_fm`, fit `final_model` with this training data, and compute the training RMSE. Then, we will process the test data with your `process_data_fm`, use `final_model` to predict `Log Sale Price` for the test data, transform the predicted and original log values back into their original forms, and compute the test RMSE. See below for an example of the code we will run to grade your model:\n",
    "\n",
    "**Note**: `delog` is a function we will run to undo the log transformation on your predictions/original sale prices.\n",
    "```\n",
    "final_model = lm.LinearRegression(fit_intercept=True)\n",
    "\n",
    "training_data = pd.read_csv('cook_county_train.csv')\n",
    "test_data = pd.read_csv('cook_county_test.csv')\n",
    "\n",
    "X_train, y_train = process_data_fm(training_data)\n",
    "X_test, y_test = process_data_fm(test_data)\n",
    "\n",
    "final_model.fit(X_train, y_train)\n",
    "y_predicted_train = final_model.predict(X_train)\n",
    "y_predicted_test = final_model.predict(X_test)\n",
    "\n",
    "training_rmse = rmse(delog(y_predicted_train), delog(y_train))\n",
    "test_rmse = rmse(delog(y_predicted_test), delog(y_test))\n",
    "```\n",
    "\n",
    "**Note:** It is your duty to make sure that all of your feature engineering and selection happens in `process_data_fm`, and that the function performs as expected without errors. We will **NOT** accept regrade requests that require us to go back and run code that require typo/bug fixes.\n",
    "\n",
    "**Hint:** Some features may have missing values in the test set but not in the training set. Make sure `process_data_fm` handles missing values appropriately for each feature!\n",
    "\n",
    "**Note**: You **MUST remove any additional new cells you add below the current one before submitting to Gradescope** to avoid any autograder errors. \n",
    "\n",
    "### Grading Scheme\n",
    "\n",
    "Your grade for Question 8 will be based on your training RMSE and test RMSE. The thresholds are as follows:\n",
    "\n",
    "Points | 3 | 2 | 1 | 0\n",
    "--- | --- | --- | --- | ---\n",
    "Training RMSE | Less than 80k | [80k, 160k) | [160k, 260k) | More than 260k\n",
    "\n",
    "Points | 3 | 2 | 1 | 0\n",
    "--- | --- | --- | --- | ---\n",
    "Test RMSE | Less than 85k | [85k, 165k) | [165k, 265k) | More than 265k\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q8\n",
    "points: 6\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    2.047920e+05\n",
       "mean     2.451646e+05\n",
       "std      3.628694e+05\n",
       "min      1.000000e+00\n",
       "25%      4.520000e+04\n",
       "50%      1.750000e+05\n",
       "75%      3.120000e+05\n",
       "max      7.100000e+07\n",
       "Name: Sale Price, dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_data.describe()['Sale Price']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👋 So we can pick between `Sale Price` between 45200 ~ 312000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SF    204792\n",
       "Name: Modeling Group, dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_data['Modeling Group'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "👋 Remove this coulumn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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>Unnamed: 0</th>\n",
       "      <th>PIN</th>\n",
       "      <th>Property Class</th>\n",
       "      <th>Neighborhood Code</th>\n",
       "      <th>Land Square Feet</th>\n",
       "      <th>Town Code</th>\n",
       "      <th>Apartments</th>\n",
       "      <th>Wall Material</th>\n",
       "      <th>Roof Material</th>\n",
       "      <th>Basement</th>\n",
       "      <th>...</th>\n",
       "      <th>Sale Quarter of Year</th>\n",
       "      <th>Sale Month of Year</th>\n",
       "      <th>Sale Half of Year</th>\n",
       "      <th>Most Recent Sale</th>\n",
       "      <th>Age Decade</th>\n",
       "      <th>Pure Market Filter</th>\n",
       "      <th>Garage Indicator</th>\n",
       "      <th>Neigborhood Code (mapping)</th>\n",
       "      <th>Town and Neighborhood</th>\n",
       "      <th>Lot Size</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>17294100610000</td>\n",
       "      <td>203</td>\n",
       "      <td>50</td>\n",
       "      <td>2500.0</td>\n",
       "      <td>76</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>13.2</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>50</td>\n",
       "      <td>7650</td>\n",
       "      <td>2500.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>13272240180000</td>\n",
       "      <td>202</td>\n",
       "      <td>120</td>\n",
       "      <td>3780.0</td>\n",
       "      <td>71</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.6</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>120</td>\n",
       "      <td>71120</td>\n",
       "      <td>3780.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>25221150230000</td>\n",
       "      <td>202</td>\n",
       "      <td>210</td>\n",
       "      <td>4375.0</td>\n",
       "      <td>70</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.2</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>210</td>\n",
       "      <td>70210</td>\n",
       "      <td>4375.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>10251130030000</td>\n",
       "      <td>203</td>\n",
       "      <td>220</td>\n",
       "      <td>4375.0</td>\n",
       "      <td>17</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>6.3</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>220</td>\n",
       "      <td>17220</td>\n",
       "      <td>4375.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>31361040550000</td>\n",
       "      <td>202</td>\n",
       "      <td>120</td>\n",
       "      <td>8400.0</td>\n",
       "      <td>32</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>6.3</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>120</td>\n",
       "      <td>32120</td>\n",
       "      <td>8400.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204787</th>\n",
       "      <td>204787</td>\n",
       "      <td>25163010260000</td>\n",
       "      <td>202</td>\n",
       "      <td>321</td>\n",
       "      <td>4375.0</td>\n",
       "      <td>72</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5.8</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>321</td>\n",
       "      <td>72321</td>\n",
       "      <td>4375.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204788</th>\n",
       "      <td>204788</td>\n",
       "      <td>5063010090000</td>\n",
       "      <td>204</td>\n",
       "      <td>21</td>\n",
       "      <td>16509.0</td>\n",
       "      <td>23</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>9.3</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>21</td>\n",
       "      <td>2321</td>\n",
       "      <td>16509.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204789</th>\n",
       "      <td>204789</td>\n",
       "      <td>16333020150000</td>\n",
       "      <td>202</td>\n",
       "      <td>90</td>\n",
       "      <td>3810.0</td>\n",
       "      <td>15</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>5.9</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>90</td>\n",
       "      <td>1590</td>\n",
       "      <td>3810.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204790</th>\n",
       "      <td>204790</td>\n",
       "      <td>9242030500000</td>\n",
       "      <td>203</td>\n",
       "      <td>80</td>\n",
       "      <td>6650.0</td>\n",
       "      <td>22</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>80</td>\n",
       "      <td>2280</td>\n",
       "      <td>6650.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>204791</th>\n",
       "      <td>204791</td>\n",
       "      <td>19102030080000</td>\n",
       "      <td>203</td>\n",
       "      <td>30</td>\n",
       "      <td>2500.0</td>\n",
       "      <td>72</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>...</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>4.7</td>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>30</td>\n",
       "      <td>7230</td>\n",
       "      <td>2500.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>204792 rows × 61 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "        Unnamed: 0             PIN  Property Class  Neighborhood Code  \\\n",
       "0                0  17294100610000             203                 50   \n",
       "1                1  13272240180000             202                120   \n",
       "2                2  25221150230000             202                210   \n",
       "3                3  10251130030000             203                220   \n",
       "4                4  31361040550000             202                120   \n",
       "...            ...             ...             ...                ...   \n",
       "204787      204787  25163010260000             202                321   \n",
       "204788      204788   5063010090000             204                 21   \n",
       "204789      204789  16333020150000             202                 90   \n",
       "204790      204790   9242030500000             203                 80   \n",
       "204791      204791  19102030080000             203                 30   \n",
       "\n",
       "        Land Square Feet  Town Code  Apartments  Wall Material  Roof Material  \\\n",
       "0                 2500.0         76         0.0            2.0            1.0   \n",
       "1                 3780.0         71         0.0            2.0            1.0   \n",
       "2                 4375.0         70         0.0            2.0            1.0   \n",
       "3                 4375.0         17         0.0            3.0            1.0   \n",
       "4                 8400.0         32         0.0            3.0            1.0   \n",
       "...                  ...        ...         ...            ...            ...   \n",
       "204787            4375.0         72         0.0            2.0            1.0   \n",
       "204788           16509.0         23         0.0            1.0            1.0   \n",
       "204789            3810.0         15         0.0            2.0            1.0   \n",
       "204790            6650.0         22         0.0            2.0            1.0   \n",
       "204791            2500.0         72         0.0            1.0            1.0   \n",
       "\n",
       "        Basement  ...  Sale Quarter of Year  Sale Month of Year  \\\n",
       "0            1.0  ...                     3                   9   \n",
       "1            1.0  ...                     2                   5   \n",
       "2            2.0  ...                     1                   2   \n",
       "3            1.0  ...                     3                   7   \n",
       "4            2.0  ...                     2                   6   \n",
       "...          ...  ...                   ...                 ...   \n",
       "204787       1.0  ...                     3                   7   \n",
       "204788       1.0  ...                     1                   3   \n",
       "204789       1.0  ...                     1                   1   \n",
       "204790       1.0  ...                     1                   2   \n",
       "204791       1.0  ...                     2                   4   \n",
       "\n",
       "        Sale Half of Year  Most Recent Sale  Age Decade  Pure Market Filter  \\\n",
       "0                       2               1.0        13.2                   0   \n",
       "1                       1               1.0         9.6                   1   \n",
       "2                       1               0.0        11.2                   1   \n",
       "3                       2               1.0         6.3                   1   \n",
       "4                       1               0.0         6.3                   1   \n",
       "...                   ...               ...         ...                 ...   \n",
       "204787                  2               0.0         5.8                   1   \n",
       "204788                  1               1.0         9.3                   1   \n",
       "204789                  1               1.0         5.9                   1   \n",
       "204790                  1               1.0         6.0                   1   \n",
       "204791                  1               0.0         4.7                   1   \n",
       "\n",
       "        Garage Indicator  Neigborhood Code (mapping)  Town and Neighborhood  \\\n",
       "0                    0.0                          50                   7650   \n",
       "1                    1.0                         120                  71120   \n",
       "2                    1.0                         210                  70210   \n",
       "3                    1.0                         220                  17220   \n",
       "4                    1.0                         120                  32120   \n",
       "...                  ...                         ...                    ...   \n",
       "204787               1.0                         321                  72321   \n",
       "204788               1.0                          21                   2321   \n",
       "204789               1.0                          90                   1590   \n",
       "204790               1.0                          80                   2280   \n",
       "204791               0.0                          30                   7230   \n",
       "\n",
       "        Lot Size  \n",
       "0         2500.0  \n",
       "1         3780.0  \n",
       "2         4375.0  \n",
       "3         4375.0  \n",
       "4         8400.0  \n",
       "...          ...  \n",
       "204787    4375.0  \n",
       "204788   16509.0  \n",
       "204789    3810.0  \n",
       "204790    6650.0  \n",
       "204791    2500.0  \n",
       "\n",
       "[204792 rows x 61 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_data.drop(['Modeling Group', 'Description'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Unnamed: 0', 'PIN', 'Property Class', 'Neighborhood Code',\n",
       "       'Land Square Feet', 'Town Code', 'Apartments', 'Wall Material',\n",
       "       'Roof Material', 'Basement', 'Basement Finish', 'Central Heating',\n",
       "       'Other Heating', 'Central Air', 'Fireplaces', 'Attic Type',\n",
       "       'Attic Finish', 'Design Plan', 'Cathedral Ceiling',\n",
       "       'Construction Quality', 'Site Desirability', 'Garage 1 Size',\n",
       "       'Garage 1 Material', 'Garage 1 Attachment', 'Garage 1 Area',\n",
       "       'Garage 2 Size', 'Garage 2 Material', 'Garage 2 Attachment',\n",
       "       'Garage 2 Area', 'Porch', 'Other Improvements', 'Building Square Feet',\n",
       "       'Repair Condition', 'Multi Code', 'Number of Commercial Units',\n",
       "       'Estimate (Land)', 'Estimate (Building)', 'Deed No.', 'Sale Price',\n",
       "       'Longitude', 'Latitude', 'Census Tract', 'Multi Property Indicator',\n",
       "       'Modeling Group', 'Age', 'Use', 'O'Hare Noise', 'Floodplain',\n",
       "       'Road Proximity', 'Sale Year', 'Sale Quarter', 'Sale Half-Year',\n",
       "       'Sale Quarter of Year', 'Sale Month of Year', 'Sale Half of Year',\n",
       "       'Most Recent Sale', 'Age Decade', 'Pure Market Filter',\n",
       "       'Garage Indicator', 'Neigborhood Code (mapping)',\n",
       "       'Town and Neighborhood', 'Description', 'Lot Size'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "full_data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Please include all of your feature engineering process inside this function.\n",
    "# Do not modify the parameters of this function.\n",
    "def process_data_fm(data, is_test_set=False):\n",
    "    data = remove_outliers(data, 'Sale Price', lower = 45200, upper = 312000)\n",
    "    data = data.drop(['Modeling Group', 'Description'], axis = 1)\n",
    "    \n",
    "    data['Log Sale Price'] = np.log(data['Sale Price'])\n",
    "    data['Log Building Square Feet'] = np.log(data['Building Square Feet'])\n",
    "    \n",
    "\n",
    "    # standardize\n",
    "    data = (data - data.mean(axis = 0)) / data.std(axis = 0)\n",
    "    \n",
    "    data = select_columns(\n",
    "        data,\n",
    "        'Log Sale Price',\n",
    "        'Log Building Square Feet',\n",
    "        'Number of Commercial Units',\n",
    "        'Age',\n",
    "        'Lot Size'\n",
    "    )\n",
    "    # Return predictors and response variables separately\n",
    "    X = data.drop(['Log Sale Price'], axis = 1)\n",
    "    y = data.loc[:, 'Log Sale Price']\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hell(\n",
    "    final_model, \n",
    "    process_data_fm, \n",
    "    threshold, \n",
    "    train_data_path, \n",
    "    test_data_path, \n",
    "    is_kaggle=False, \n",
    "    is_ranking=False\n",
    "):\n",
    "    def rmse(predicted, actual):\n",
    "        return np.sqrt(np.mean((actual - predicted)**2))\n",
    "\n",
    "    training_data = pd.read_csv(train_data_path, index_col='Unnamed: 0')\n",
    "    X_train, y_train = process_data_fm(training_data)\n",
    "    final_model.fit(X_train, y_train)\n",
    "    y_predicted = final_model.predict(X_train)\n",
    "    loss = rmse(np.exp(y_predicted), np.exp(y_train))\n",
    "    return loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p><strong><pre style='display: inline;'>q8</pre></strong> passed!</p>"
      ],
      "text/plain": [
       "q8 results: All test cases passed!"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check(\"q8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations on finishing your prediction model for home sale prices in Cook County! In the following section, we'll delve deeper into the implications of predictive modeling within the CCAO case study - especially because statistical modeling is how the CCAO valuates properties. \n",
    "\n",
    "Refer to [Lecture 15](https://ds100.org/su21/lecture/lec15/) if you're having trouble getting started!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "## Question 9\n",
    "\n",
    "When evaluating your model, we used root mean squared error. In the context of estimating the value of houses, what does error mean for an individual homeowner? How does it affect them in terms of property taxes?\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q9\n",
    "points: 2\n",
    "manual: true\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Type your answer here, replacing this text._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "In the case of the Cook County Assessor’s Office, Chief Data Officer Rob Ross states that fair property tax rates are contingent on whether property values are assessed accurately - that they’re valued at what they’re worth, relative to properties with similar characteristics. This implies that having a more accurate model results in fairer assessments. The goal of the property assessment process for the CCAO, then, is to be as accurate as possible. \n",
    "\n",
    "When the use of algorithms and statistical modeling has real-world consequences, we often refer to the idea of fairness as a measurement of how socially responsible our work is. But fairness is incredibly multifaceted: Is a fair model one that minimizes loss - one that generates accurate results? Is it one that utilizes \"unbiased\" data? Or is fairness a broader goal that takes historical contexts into account?\n",
    "\n",
    "These approaches to fairness are not mutually exclusive. If we look beyond error functions and technical measures of accuracy, we'd not only consider _individual_ cases of fairness, but also what fairness - and justice - means to marginalized communities on a broader scale. We'd ask: What does it mean when homes in predominantly Black and Hispanic communities in Cook County are consistently overvalued, resulting in proportionally higher property taxes? When the white neighborhoods in Cook County are consistently undervalued, resulting in proportionally lower property taxes? \n",
    "\n",
    "Having \"accurate\" predictions doesn't necessarily address larger historical trends and inequities, and fairness in property assessments in taxes works beyond the CCAO's valuation model. Disassociating accurate predictions from a fair system is vital to approaching justice at multiple levels. Take Evanston, IL - a suburb in Cook County - as an example of housing equity beyond just improving a property valuation model: Their City Council members [recently approved reparations for African American residents](https://www.usnews.com/news/health-news/articles/2021-03-23/chicago-suburb-approves-government-reparations-for-black-residents).\n",
    "\n",
    "\n",
    "## Question 10\n",
    "\n",
    "In your own words, describe how you would define fairness in property assessments and taxes.\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q10\n",
    "points: 1\n",
    "manual: True\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Type your answer here, replacing this text._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "\n",
    "\n",
    "## The CCAO and Transparency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, in their approach to fair property valuations, the CCAO has also pushed for transparency initiatives in the property tax assessment system. After a lawsuit was filed against the CCAO for producing [“racially discriminatory assessments and taxes,\"](https://harris.uchicago.edu/news-events/news/prof-chris-berry-testifies-institutional-racism-cook-county-property-taxes) the Office decided that these inequities would be best addressed by making the assessment process more transparent to Cook County constituents.  \n",
    "\n",
    "These transparency initiatives include publishing all of the CCAO’s work on [GitLab](https://gitlab.com/ccao-data-science---modeling). By allowing the public to access any updates to the system in real-time, the Office argues that they increase accessibility to a process that had previously been blackboxed - obscured and hidden - from the public. Ultimately, the hope is that, by exposing the inner workings of the CCAO’s property valuation process, the CCAO's assessment results could be publicly verified as accurate and therefore trusted to be fair."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<!-- BEGIN QUESTION -->\n",
    "\n",
    "## Question 11\n",
    "\n",
    "Take a look at the Residential Automated Valuation Model files under the Models subgroup in the CCAO’s [GitLab](https://gitlab.com/ccao-data-science---modeling). Without directly looking at any code, do you feel that the documentation sufficiently explains how the residential valuation model works? Which part(s) of the documentation might be difficult for nontechnical audiences to understand?\n",
    "\n",
    "<!--\n",
    "BEGIN QUESTION\n",
    "name: q11\n",
    "points: 2\n",
    "manual: true\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Type your answer here, replacing this text._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- END QUESTION -->\n",
    "\n",
    "\n",
    "\n",
    "You might feel that the model's inner workings are beyond your pay grade - it's far more complex than the model you built in this assignment, after all! Though we won't delve further into the role of transparency in the broader CCAO case study, consider its effectiveness and/or ineffectiveness: Is the system truly transparent if it's inaccessible to Cook County constituents? Do transparency measures actually bolster the accuracy of a model - or do they only affect the _perceived_ accuracy of a model? \n",
    "\n",
    "And if you're interested in thinking more about transparency measures, take Data 104! But for now..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congratulations! You have finished Homework 9!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "---\n",
    "\n",
    "To double-check your work, the cell below will rerun all of the autograder tests."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "q1 results: All test cases passed!\n",
       "\n",
       "q3 results: All test cases passed!\n",
       "\n",
       "q4 results: All test cases passed!\n",
       "\n",
       "q5 results: All test cases passed!\n",
       "\n",
       "q8 results: All test cases passed!"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grader.check_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Submission\n",
    "\n",
    "Make sure you have run all cells in your notebook in order before running the cell below, so that all images/graphs appear in the output. The cell below will generate a zip file for you to submit. **Please save before exporting!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "            <p>Your submission has been exported. Click <a href=\"hw9_2022_04_20T18_10_50_082032.zip\" download=\"hw9_2022_04_20T18_10_50_082032.zip\" target=\"_blank\">here</a>\n",
       "            to download the zip file.</p>\n",
       "            "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Save your notebook first, then run this cell to export your submission.\n",
    "grader.export()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Create Assignment",
  "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}