my_boston_project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Evaluation and Validtion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project: Predicting Boston Housing Prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boston housing dataset has 489 data points with 4 variables each.\n"
     ]
    }
   ],
   "source": [
    "#import libraries necessary for this project\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import ShuffleSplit\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "#import Supplementary visualization code visuals.py\n",
    "import visuals as vs\n",
    "\n",
    "# pretty display for notebook\n",
    "%matplotlib inline\n",
    "\n",
    "#load the Boston housing dataset\n",
    "\n",
    "data = pd.read_csv('dataset/housing.csv')\n",
    "prices = data['MEDV']\n",
    "features = data.drop('MEDV',axis=1)\n",
    "\n",
    "# Success\n",
    "print(\"Boston housing dataset has {} data points with {} variables each.\".format(*data.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have 489 Data Points.\n",
      "We have 4 Features.\n"
     ]
    }
   ],
   "source": [
    "#lets check how many data points we have and how many features we have ??\n",
    "print(\"We have {} Data Points.\".format(data.shape[0]))\n",
    "print(\"We have {} Features.\".format(data.shape[1]))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['RM', 'LSTAT', 'PTRATIO', 'MEDV'], dtype='object')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Checking which features we have\n",
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(489, 3)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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>RM</th>\n",
       "      <th>LSTAT</th>\n",
       "      <th>PTRATIO</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>6.575</td>\n",
       "      <td>4.98</td>\n",
       "      <td>15.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6.421</td>\n",
       "      <td>9.14</td>\n",
       "      <td>17.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>7.185</td>\n",
       "      <td>4.03</td>\n",
       "      <td>17.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>6.998</td>\n",
       "      <td>2.94</td>\n",
       "      <td>18.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7.147</td>\n",
       "      <td>5.33</td>\n",
       "      <td>18.7</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      RM  LSTAT  PTRATIO\n",
       "0  6.575   4.98     15.3\n",
       "1  6.421   9.14     17.8\n",
       "2  7.185   4.03     17.8\n",
       "3  6.998   2.94     18.7\n",
       "4  7.147   5.33     18.7"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    504000.0\n",
       "1    453600.0\n",
       "2    728700.0\n",
       "3    701400.0\n",
       "4    760200.0\n",
       "Name: MEDV, dtype: float64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 489 entries, 0 to 488\n",
      "Data columns (total 3 columns):\n",
      "RM         489 non-null float64\n",
      "LSTAT      489 non-null float64\n",
      "PTRATIO    489 non-null float64\n",
      "dtypes: float64(3)\n",
      "memory usage: 11.5 KB\n"
     ]
    }
   ],
   "source": [
    "features.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "count    4.890000e+02\n",
       "mean     4.543429e+05\n",
       "std      1.653403e+05\n",
       "min      1.050000e+05\n",
       "25%      3.507000e+05\n",
       "50%      4.389000e+05\n",
       "75%      5.187000e+05\n",
       "max      1.024800e+06\n",
       "Name: MEDV, dtype: float64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prices.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Minimum price: $105000.0\n"
     ]
    }
   ],
   "source": [
    "#Minimum price\n",
    "minimum_price = np.min(prices)\n",
    "print(\"Minimum price: ${}\".format(minimum_price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum price: $1024800.0\n"
     ]
    }
   ],
   "source": [
    "#Maximum Price\n",
    "maximum_price = np.max(prices)\n",
    "print(\"Maximum price: ${}\".format(maximum_price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Price: $454342.9447852761\n"
     ]
    }
   ],
   "source": [
    "#Mean Price\n",
    "mean_price = np.mean(prices)\n",
    "print(\"Mean Price: ${}\".format(mean_price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Median price: $438900.0\n"
     ]
    }
   ],
   "source": [
    "#Median Of price\n",
    "median_price = np.median(prices)\n",
    "print(\"Median price: ${}\".format(median_price))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard deviation of prices: $165171.13154429477\n"
     ]
    }
   ],
   "source": [
    "#Standered Daviation of price\n",
    "std_price = np.std(prices)\n",
    "print(\"Standard deviation of prices: ${}\".format(std_price))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1 - Feature Observation\n",
    "As a reminder, we are using three features from the Boston housing dataset: `'RM'`, `'LSTAT'`, and `'PTRATIO'`. For each data point (neighborhood):\n",
    "- `'RM'` is the average number of rooms among homes in the neighborhood.\n",
    "- `'LSTAT'` is the percentage of homeowners in the neighborhood considered \"lower class\" (working poor).\n",
    "- `'PTRATIO'` is the ratio of students to teachers in primary and secondary schools in the neighborhood.\n",
    "\n",
    "\n",
    "**Using your intuition, for each of the three features above, do you think that an increase in the value of that feature would lead to an **increase** in the value of `'MEDV'` or a **decrease** in the value of `'MEDV'`? Justify your answer for each.**\n",
    "\n",
    "- Would you expect a home that has an `'RM'` value(number of rooms) of 6 be worth more or less than a home that has an `'RM'` value of 7?\n",
    "- Would you expect a neighborhood that has an `'LSTAT'` value(percent of lower class workers) of 15 have home prices be worth more or less than a neighborhood that has an `'LSTAT'` value of 20?\n",
    "- Would you expect a neighborhood that has an `'PTRATIO'` value(ratio of students to teachers) of 10 have home prices be worth more or less than a neighborhood that has an `'PTRATIO'` value of 15?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Observations:\n",
    "- if we increase the value of `'RM'` then the price of house will increase.\n",
    "- if we increase the value of `'LSTAT'` then the price of house will decrease.\n",
    "- if we increase the value of `'PTRATIO'` then the price of house will decrease.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Developing a simple Model Without Extra Efforts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Predicted Price For [3.575, 1.98, 10.0] Sample is :: $508532.26538074866\n"
     ]
    }
   ],
   "source": [
    "# lets fit data into model\n",
    "X = features\n",
    "y = prices\n",
    "model_reg = LinearRegression()\n",
    "model_reg.fit(X,y)\n",
    "\n",
    "sample_house = [[3.575, 1.98, 10.0]]\n",
    "\n",
    "#Predict housing price for the sample_house\n",
    "prediction = model_reg.predict(sample_house)\n",
    "#Print Prediction\n",
    "print(\"The Predicted Price For {} Sample is :: ${}\".format(*sample_house,prediction[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's Verify Above Observations:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Predicted Price For [10.575, 1.98, 10.0] Sample is :: $1114488.9183116534\n"
     ]
    }
   ],
   "source": [
    "#increase the value of 'RM'\n",
    "sample_house = [[10.575, 1.98, 10.0]]\n",
    "#Predict housing price for the sample_house\n",
    "prediction = model_reg.predict(sample_house)\n",
    "#Print Prediction\n",
    "print(\"The Predicted Price For {} Sample is :: ${}\".format(*sample_house,prediction[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Predicted Price For [3.575, 4.0, 10.0] Sample is :: $486616.59780546196\n"
     ]
    }
   ],
   "source": [
    "#increasing the value of 'LSTAT'\n",
    "sample_house = [[3.575, 4.0, 10.0]]\n",
    "#Predict housing price for the sample_house\n",
    "prediction = model_reg.predict(sample_house)\n",
    "#Print Prediction\n",
    "print(\"The Predicted Price For {} Sample is :: ${}\".format(*sample_house,prediction[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Predicted Price For [3.575, 1.98, 15.0] Sample is :: $411071.6872050121\n"
     ]
    }
   ],
   "source": [
    "#increasing the value of 'PTRATIO'\n",
    "sample_house = [[3.575, 1.98, 15.0]]\n",
    "#Predict housing price for the sample_house\n",
    "prediction = model_reg.predict(sample_house)\n",
    "#Print Prediction\n",
    "print(\"The Predicted Price For {} Sample is :: ${}\".format(*sample_house,prediction[0]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Performance Metric\n",
    "The values for R<sup>2</sup> range from 0 to 1, which captures the percentage of squared correlation between the predicted and actual values of the **target variable**. A model with an R<sup>2</sup> of 0 is no better than a model that always predicts the *mean* of the target variable, whereas a model with an R<sup>2</sup> of 1 perfectly predicts the target variable. Any value between 0 and 1 indicates what percentage of the target variable, using this model, can be explained by the **features**. _A model can be given a negative R<sup>2</sup> as well, which indicates that the model is **arbitrarily worse** than one that always predicts the mean of the target variable._\n",
    "\n",
    "For the `performance_metric` function in the code cell below, you will need to implement the following:\n",
    "- Use `r2_score` from `sklearn.metrics` to perform a performance calculation between `y_true` and `y_predict`.\n",
    "- Assign the performance score to the `score` variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import r2_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'r2_score'\n",
    "\n",
    "def performance_metric(y_true, y_predict):\n",
    "    \"\"\" Calculates and returns the performance score between \n",
    "        true and predicted values based on the metric chosen. \"\"\"\n",
    "    \n",
    "    # Calculate the performance score between 'y_true' and 'y_predict'\n",
    "    score = r2_score(y_true,y_predict)\n",
    "    \n",
    "    # Return the score\n",
    "    return score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2 - Goodness of Fit\n",
    "Assume that a dataset contains five data points and a model made the following predictions for the target variable:\n",
    "\n",
    "| True Value | Prediction |\n",
    "| :-------------: | :--------: |\n",
    "| 3.0 | 2.5 |\n",
    "| -0.5 | 0.0 |\n",
    "| 2.0 | 2.1 |\n",
    "| 7.0 | 7.8 |\n",
    "| 4.2 | 5.3 |\n",
    "\n",
    "Run the code cell below to use the `performance_metric` function and calculate this model's coefficient of determination."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model has a coefficient of determination, R^2, of 0.923.\n"
     ]
    }
   ],
   "source": [
    "# Calculate the performance of this model\n",
    "score = performance_metric([3, -0.5, 2, 7, 4.2], [2.5, 0.0, 2.1, 7.8, 5.3])\n",
    "print(\"Model has a coefficient of determination, R^2, of {:.3f}.\".format(score))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Would you consider this model to have successfully captured the variation of the target variable? \n",
    "* Why or why not?\n",
    "\n",
    "** Hint: **  The R2 score is the proportion of the variance in the dependent variable that is predictable from the independent variable. In other words:\n",
    "* R2 score of 0 means that the dependent variable cannot be predicted from the independent variable.\n",
    "* R2 score of 1 means the dependent variable can be predicted from the independent variable.\n",
    "* R2 score between 0 and 1 indicates the extent to which the dependent variable is predictable. An \n",
    "* R2 score of 0.40 means that 40 percent of the variance in Y is predictable from X."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Answer:**  92.3 % of variance in Y is predictable from X."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation: Shuffle and Split Data\n",
    "Next implementation requires that take the Boston housing dataset and split the data into training and testing subsets. Typically, the data is also shuffled into a random order when creating the training and testing subsets to remove any bias in the ordering of the dataset.\n",
    "\n",
    "For the code cell below, you will need to implement the following:\n",
    "- Using `train_test_split` from `sklearn.model_selection` to shuffle and split the `features` and `prices` data into training and testing sets.\n",
    "  - Split the data into 80% training and 20% testing.\n",
    "  - Set the `random_state` for `train_test_split` to a value of your choice. This ensures results are consistent.\n",
    "- Assigning the train and testing splits to `X_train`, `X_test`, `y_train`, and `y_test`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training and testing split was successful.\n"
     ]
    }
   ],
   "source": [
    "#import train_test_split\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=30)\n",
    "# Success\n",
    "print(\"Training and testing split was successful.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3 - Training and Testing\n",
    "\n",
    "* What is the benefit to splitting a dataset into some ratio of training and testing subsets for a learning algorithm?\n",
    "\n",
    " **Think about how overfitting or underfitting is contingent upon how splits on data is done.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}