day10-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7db08bf4",
   "metadata": {
    "papermill": {
     "duration": 0.010396,
     "end_time": "2021-08-23T14:07:16.622602",
     "exception": false,
     "start_time": "2021-08-23T14:07:16.612206",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "**This notebook is an exercise in the [Introduction to Machine Learning](https://www.kaggle.com/learn/intro-to-machine-learning) course.  You can reference the tutorial at [this link](https://www.kaggle.com/dansbecker/underfitting-and-overfitting).**\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e5d35ed",
   "metadata": {
    "papermill": {
     "duration": 0.009008,
     "end_time": "2021-08-23T14:07:16.641505",
     "exception": false,
     "start_time": "2021-08-23T14:07:16.632497",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Recap\n",
    "You've built your first model, and now it's time to optimize the size of the tree to make better predictions. Run this cell to set up your coding environment where the previous step left off."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dee9c7f7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:16.675042Z",
     "iopub.status.busy": "2021-08-23T14:07:16.674333Z",
     "iopub.status.idle": "2021-08-23T14:07:18.006654Z",
     "shell.execute_reply": "2021-08-23T14:07:18.005842Z",
     "shell.execute_reply.started": "2021-08-23T13:56:26.635116Z"
    },
    "papermill": {
     "duration": 1.355989,
     "end_time": "2021-08-23T14:07:18.006813",
     "exception": false,
     "start_time": "2021-08-23T14:07:16.650824",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation MAE: 29,653\n",
      "\n",
      "Setup complete\n"
     ]
    }
   ],
   "source": [
    "# Code you have previously used to load data\n",
    "import pandas as pd\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "\n",
    "\n",
    "# Path of the file to read\n",
    "iowa_file_path = '../input/home-data-for-ml-course/train.csv'\n",
    "\n",
    "home_data = pd.read_csv(iowa_file_path)\n",
    "# Create target object and call it y\n",
    "y = home_data.SalePrice\n",
    "# Create X\n",
    "features = ['LotArea', 'YearBuilt', '1stFlrSF', '2ndFlrSF', 'FullBath', 'BedroomAbvGr', 'TotRmsAbvGrd']\n",
    "X = home_data[features]\n",
    "\n",
    "# Split into validation and training data\n",
    "train_X, val_X, train_y, val_y = train_test_split(X, y, random_state=1)\n",
    "\n",
    "# Specify Model\n",
    "iowa_model = DecisionTreeRegressor(random_state=1)\n",
    "# Fit Model\n",
    "iowa_model.fit(train_X, train_y)\n",
    "\n",
    "# Make validation predictions and calculate mean absolute error\n",
    "val_predictions = iowa_model.predict(val_X)\n",
    "val_mae = mean_absolute_error(val_predictions, val_y)\n",
    "print(\"Validation MAE: {:,.0f}\".format(val_mae))\n",
    "\n",
    "# Set up code checking\n",
    "from learntools.core import binder\n",
    "binder.bind(globals())\n",
    "from learntools.machine_learning.ex5 import *\n",
    "print(\"\\nSetup complete\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "552b761d",
   "metadata": {
    "papermill": {
     "duration": 0.009357,
     "end_time": "2021-08-23T14:07:18.026284",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.016927",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Exercises\n",
    "You could write the function `get_mae` yourself. For now, we'll supply it. This is the same function you read about in the previous lesson. Just run the cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4126eef7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:18.051557Z",
     "iopub.status.busy": "2021-08-23T14:07:18.050833Z",
     "iopub.status.idle": "2021-08-23T14:07:18.053697Z",
     "shell.execute_reply": "2021-08-23T14:07:18.052951Z",
     "shell.execute_reply.started": "2021-08-23T13:56:37.746512Z"
    },
    "papermill": {
     "duration": 0.017918,
     "end_time": "2021-08-23T14:07:18.053859",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.035941",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y):\n",
    "    model = DecisionTreeRegressor(max_leaf_nodes=max_leaf_nodes, random_state=0)\n",
    "    model.fit(train_X, train_y)\n",
    "    preds_val = model.predict(val_X)\n",
    "    mae = mean_absolute_error(val_y, preds_val)\n",
    "    return(mae)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a786da5b",
   "metadata": {
    "papermill": {
     "duration": 0.010116,
     "end_time": "2021-08-23T14:07:18.073854",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.063738",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Step 1: Compare Different Tree Sizes\n",
    "Write a loop that tries the following values for *max_leaf_nodes* from a set of possible values.\n",
    "\n",
    "Call the *get_mae* function on each value of max_leaf_nodes. Store the output in some way that allows you to select the value of `max_leaf_nodes` that gives the most accurate model on your data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2e072ee7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:18.103723Z",
     "iopub.status.busy": "2021-08-23T14:07:18.102701Z",
     "iopub.status.idle": "2021-08-23T14:07:18.155397Z",
     "shell.execute_reply": "2021-08-23T14:07:18.155953Z",
     "shell.execute_reply.started": "2021-08-23T14:03:43.298494Z"
    },
    "papermill": {
     "duration": 0.07205,
     "end_time": "2021-08-23T14:07:18.156118",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.084068",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{5: 35044.51299744237, 25: 29016.41319191076, 50: 27405.930473214907, 100: 27282.50803885739, 250: 27893.822225701646, 500: 29454.18598068598}\n"
     ]
    },
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.5, \"interactionType\": 1, \"questionType\": 1, \"questionId\": \"1_BestTreeSize\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct</span>"
      ],
      "text/plain": [
       "Correct"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "candidate_max_leaf_nodes = [5, 25, 50, 100, 250, 500]\n",
    "# Write loop to find the ideal tree size from candidate_max_leaf_nodes\n",
    "all_mae = {}\n",
    "for leaf in candidate_max_leaf_nodes:\n",
    "    all_mae[leaf]= get_mae(leaf, train_X, val_X, train_y, val_y)\n",
    "print(all_mae)\n",
    "\n",
    "# Store the best value of max_leaf_nodes (it will be either 5, 25, 50, 100, 250 or 500)\n",
    "best_tree_size = min(all_mae, key=all_mae.get)\n",
    "\n",
    "# Check your answer\n",
    "step_1.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "022371ac",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:18.184158Z",
     "iopub.status.busy": "2021-08-23T14:07:18.183139Z",
     "iopub.status.idle": "2021-08-23T14:07:18.190175Z",
     "shell.execute_reply": "2021-08-23T14:07:18.189658Z",
     "shell.execute_reply.started": "2021-08-23T14:03:50.814418Z"
    },
    "papermill": {
     "duration": 0.023147,
     "end_time": "2021-08-23T14:07:18.190319",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.167172",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 1, \"questionId\": \"1_BestTreeSize\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> \n",
       "```python\n",
       "# Here is a short solution with a dict comprehension.\n",
       "# The lesson gives an example of how to do this with an explicit loop.\n",
       "scores = {leaf_size: get_mae(leaf_size, train_X, val_X, train_y, val_y) for leaf_size in candidate_max_leaf_nodes}\n",
       "best_tree_size = min(scores, key=scores.get)\n",
       "\n",
       "```"
      ],
      "text/plain": [
       "Solution: \n",
       "```python\n",
       "# Here is a short solution with a dict comprehension.\n",
       "# The lesson gives an example of how to do this with an explicit loop.\n",
       "scores = {leaf_size: get_mae(leaf_size, train_X, val_X, train_y, val_y) for leaf_size in candidate_max_leaf_nodes}\n",
       "best_tree_size = min(scores, key=scores.get)\n",
       "\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# The lines below will show you a hint or the solution.\n",
    "# step_1.hint() \n",
    "step_1.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a178bab1",
   "metadata": {
    "papermill": {
     "duration": 0.011712,
     "end_time": "2021-08-23T14:07:18.214788",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.203076",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Step 2: Fit Model Using All Data\n",
    "You know the best tree size. If you were going to deploy this model in practice, you would make it even more accurate by using all of the data and keeping that tree size.  That is, you don't need to hold out the validation data now that you've made all your modeling decisions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d8a6afe4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:18.247833Z",
     "iopub.status.busy": "2021-08-23T14:07:18.246862Z",
     "iopub.status.idle": "2021-08-23T14:07:18.261511Z",
     "shell.execute_reply": "2021-08-23T14:07:18.260963Z",
     "shell.execute_reply.started": "2021-08-23T14:06:49.570372Z"
    },
    "papermill": {
     "duration": 0.034406,
     "end_time": "2021-08-23T14:07:18.261661",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.227255",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"outcomeType\": 1, \"valueTowardsCompletion\": 0.5, \"interactionType\": 1, \"questionType\": 2, \"questionId\": \"2_FitModelWithAllData\", \"learnToolsVersion\": \"0.3.4\", \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\"}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc33\">Correct</span>"
      ],
      "text/plain": [
       "Correct"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fill in argument to make optimal size and uncomment\n",
    "final_model = DecisionTreeRegressor(max_leaf_nodes=best_tree_size, random_state=0)\n",
    "\n",
    "# fit the final model and uncomment the next two lines\n",
    "final_model.fit(X, y)\n",
    "\n",
    "# Check your answer\n",
    "step_2.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d130f18c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-08-23T14:07:18.294108Z",
     "iopub.status.busy": "2021-08-23T14:07:18.293419Z",
     "iopub.status.idle": "2021-08-23T14:07:18.299510Z",
     "shell.execute_reply": "2021-08-23T14:07:18.300009Z",
     "shell.execute_reply.started": "2021-08-23T14:06:54.350022Z"
    },
    "papermill": {
     "duration": 0.024858,
     "end_time": "2021-08-23T14:07:18.300176",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.275318",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "parent.postMessage({\"jupyterEvent\": \"custom.exercise_interaction\", \"data\": {\"interactionType\": 3, \"questionType\": 2, \"questionId\": \"2_FitModelWithAllData\", \"learnToolsVersion\": \"0.3.4\", \"valueTowardsCompletion\": 0.0, \"failureMessage\": \"\", \"exceptionClass\": \"\", \"trace\": \"\", \"outcomeType\": 4}}, \"*\")"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "<span style=\"color:#33cc99\">Solution:</span> \n",
       "```python\n",
       "# Fit the model with best_tree_size. Fill in argument to make optimal size\n",
       "final_model = DecisionTreeRegressor(max_leaf_nodes=best_tree_size, random_state=1)\n",
       "\n",
       "# fit the final model\n",
       "final_model.fit(X, y)\n",
       "```"
      ],
      "text/plain": [
       "Solution: \n",
       "```python\n",
       "# Fit the model with best_tree_size. Fill in argument to make optimal size\n",
       "final_model = DecisionTreeRegressor(max_leaf_nodes=best_tree_size, random_state=1)\n",
       "\n",
       "# fit the final model\n",
       "final_model.fit(X, y)\n",
       "```"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# step_2.hint()\n",
    "step_2.solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cb4efc6",
   "metadata": {
    "papermill": {
     "duration": 0.013694,
     "end_time": "2021-08-23T14:07:18.327936",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.314242",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "You've tuned this model and improved your results. But we are still using Decision Tree models, which are not very sophisticated by modern machine learning standards. In the next step you will learn to use Random Forests to improve your models even more.\n",
    "\n",
    "# Keep Going\n",
    "\n",
    "You are ready for **[Random Forests](https://www.kaggle.com/dansbecker/random-forests).**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc971b1e",
   "metadata": {
    "papermill": {
     "duration": 0.013682,
     "end_time": "2021-08-23T14:07:18.355568",
     "exception": false,
     "start_time": "2021-08-23T14:07:18.341886",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "---\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "*Have questions or comments? Visit the [Learn Discussion forum](https://www.kaggle.com/learn-forum/161285) to chat with other Learners.*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 11.826485,
   "end_time": "2021-08-23T14:07:19.931988",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2021-08-23T14:07:08.105503",
   "version": "2.3.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}