3.1-House-Price-Prediction-MLP.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "!pip install -r https://raw.githubusercontent.com/datamllab/automl-in-action-notebooks/master/requirements.txt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "tf.random.set_seed(42)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Load data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "# Import the dataset loading function from sklearn\n",
    "from sklearn.datasets import fetch_california_housing\n",
    "\n",
    "# Load the California housing dataset\n",
    "house_dataset = fetch_california_housing()\n",
    "\n",
    "# Display the oringal data\n",
    "house_dataset.keys()\n",
    "\n",
    "# Import pandas package to format the data\n",
    "import pandas as pd\n",
    "\n",
    "# Extract features with their names into the a dataframe format\n",
    "data = pd.DataFrame(house_dataset.data, columns=house_dataset.feature_names)\n",
    "\n",
    "# Extract target with their names into a pd.Series object with name MEDV\n",
    "target = pd.Series(house_dataset.target, name=\"MEDV\")\n",
    "\n",
    "# Visualize the first 5 samples of the data\n",
    "data.head(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "# Split data into training and test dataset\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "train_data, test_data, train_targets, test_targets = train_test_split(\n",
    "    data, target, test_size=0.2, random_state=42\n",
    ")\n",
    "\n",
    "# Check the shape of whole dataset and the splited training and test set\n",
    "print(\"--Shape of the whole data--\\n {}\".format(data.shape))\n",
    "print(\"\\n--Shape of the target vector--\\n {}\".format(target.shape))\n",
    "print(\"\\n--Shape of the training data--\\n {}\".format(train_data.shape))\n",
    "print(\"\\n--Shape of the testing data--\\n {}\".format(test_data.shape))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "train_data.shape, test_data.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "train_data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Data Preparation: normalization\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "\n",
    "def norm(x, mean, std):\n",
    "    return (x - mean) / std\n",
    "\n",
    "\n",
    "mean = train_data.mean(axis=0)\n",
    "std = train_data.std(axis=0)\n",
    "\n",
    "normed_train_data = norm(train_data, mean, std)\n",
    "normed_test_data = norm(test_data, mean, std)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Build up an MLP\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "from tensorflow import keras\n",
    "from tensorflow.keras import layers\n",
    "\n",
    "model = keras.Sequential(\n",
    "    [\n",
    "        layers.Dense(64, activation=\"relu\", input_shape=[8]),\n",
    "        layers.Dense(64, activation=\"relu\"),\n",
    "        layers.Dense(1),\n",
    "    ]\n",
    ")\n",
    "\n",
    "# Now try out the model. Take a batch of 5 examples from the training data and call model.predict on it.\n",
    "example_batch = normed_train_data[:5]\n",
    "example_result = model.predict(example_batch)\n",
    "example_result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "# Customize the optimizer configuration (learning rate here)\n",
    "optimizer = tf.keras.optimizers.RMSprop(0.01)\n",
    "model.compile(loss=\"mse\", optimizer=optimizer, metrics=[\"mae\", \"mse\"])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Train & test the model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model.fit(normed_train_data, train_targets, epochs=300, batch_size=1024, verbose=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "loss, mae, mse = model.evaluate(normed_test_data, test_targets, verbose=0)\n",
    "mse\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "### Tune the number of epochs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "# Train the model (in silent mode, verbose=0)\n",
    "\n",
    "\n",
    "def build_model():\n",
    "    model = keras.Sequential(\n",
    "        [\n",
    "            layers.Dense(\n",
    "                64, activation=\"relu\", input_shape=[normed_train_data.shape[1]]\n",
    "            ),\n",
    "            layers.Dense(64, activation=\"relu\"),\n",
    "            layers.Dense(1),\n",
    "        ]\n",
    "    )\n",
    "    optimizer = tf.keras.optimizers.RMSprop(0.01)\n",
    "    model.compile(loss=\"mse\", optimizer=optimizer, metrics=[\"mae\", \"mse\"])\n",
    "    return model\n",
    "\n",
    "\n",
    "model = build_model()\n",
    "\n",
    "EPOCHS = 500\n",
    "history = model.fit(\n",
    "    normed_train_data,\n",
    "    train_targets,\n",
    "    validation_split=0.2,\n",
    "    epochs=EPOCHS,\n",
    "    batch_size=1024,\n",
    "    verbose=1,\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "hist = pd.DataFrame(history.history)\n",
    "hist[\"epoch\"] = history.epoch\n",
    "hist.tail()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(hist[\"epoch\"], hist[\"mse\"], label=\"train mse\")\n",
    "plt.plot(hist[\"epoch\"], hist[\"val_mse\"], label=\"val mse\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"MSE\")\n",
    "# Set a title of the current axes.\n",
    "plt.title(\"Training and Validation MSE by Epoch\")\n",
    "# show a legend on the plot\n",
    "plt.legend()\n",
    "# Display a figure.\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def smooth_curve(values, std=5):\n",
    "    # gaussian smoothing: Smooths a list of values by convolving with a gussian.\n",
    "    width = std * 4\n",
    "    x = np.linspace(-width, width, 2 * width + 1)\n",
    "    kernel = np.exp(-((x / 5) ** 2))\n",
    "\n",
    "    values = np.array(values)\n",
    "    weights = np.ones_like(values)\n",
    "\n",
    "    smoothed_values = np.convolve(values, kernel, mode=\"same\")\n",
    "    smoothed_weights = np.convolve(weights, kernel, mode=\"same\")\n",
    "\n",
    "    return smoothed_values / smoothed_weights\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.plot(hist[\"epoch\"], smooth_curve(hist[\"mse\"]), label=\"train mse\")\n",
    "plt.plot(hist[\"epoch\"], smooth_curve(hist[\"val_mse\"]), label=\"val mse\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"MSE\")\n",
    "plt.ylim((0, 0.5))\n",
    "# Set a title of the current axes.\n",
    "plt.title(\"Training and Validation MSE by Epoch (smoothed)\")\n",
    "# show a legend on the plot\n",
    "plt.legend()\n",
    "# Display a figure.\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text"
   },
   "source": [
    "## Final fit model with full data & test model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "model = build_model()\n",
    "model.fit(normed_train_data, train_targets, epochs=150, batch_size=1024, verbose=1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "loss, mae, mse = model.evaluate(normed_test_data, test_targets, verbose=0)\n",
    "mse\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab_type": "code"
   },
   "outputs": [],
   "source": [
    "test_predictions = model.predict(normed_test_data).flatten()\n",
    "\n",
    "a = plt.axes(aspect=\"equal\")\n",
    "plt.scatter(test_targets, test_predictions)\n",
    "plt.xlabel(\"True Values [MEDV]\")\n",
    "plt.ylabel(\"Predictions [MEDV]\")\n",
    "lims = [0, 5]\n",
    "plt.xlim(lims)\n",
    "plt.ylim(lims)\n",
    "_ = plt.plot(lims, lims)\n"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "3.1-House-Price-Prediction-MLP",
   "private_outputs": false,
   "provenance": [],
   "toc_visible": true
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}