04_linear_regression__housing__with_standardization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import sklearn.datasets\n",
    "import tensorflow as tf\n",
    "\n",
    "# Prints numpy arrays nicer\n",
    "np.set_printoptions(precision=2, suppress=True, linewidth=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "boston_housing = sklearn.datasets.load_boston()\n",
    "# Uncomment the following line for a description of the dataset.\n",
    "# print(boston_housing['DESCR'])\n",
    "xs = boston_housing.data\n",
    "ys = boston_housing.target\n",
    "\n",
    "standardize_xs = True\n",
    "if standardize_xs:\n",
    "    xs = (xs - np.mean(xs, axis=0)) / np.std(xs, axis=0)\n",
    "\n",
    "data = list(zip(xs, ys))\n",
    "\n",
    "# Perform 60% / 40% training/test split\n",
    "split_index = int(len(data) * 0.6)\n",
    "train_data = data[:split_index]\n",
    "test_data = data[split_index:]\n",
    "print('Num training examples:', len(train_data))\n",
    "print('Num testing examples:', len(test_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperparameters\n",
    "learning_rate = 0.000001 if not standardize_xs else 0.005\n",
    "num_epochs = 500 if not standardize_xs else 100\n",
    "num_features = len(train_data[0][0])\n",
    "\n",
    "# Model Definition\n",
    "x = tf.placeholder(tf.float32, shape=[num_features])\n",
    "y = tf.placeholder(tf.float32)\n",
    "\n",
    "w = tf.Variable(tf.random_normal(shape=[num_features], mean=0, stddev=1))\n",
    "b = tf.Variable(0.0)\n",
    "\n",
    "y_prediction = tf.tensordot(x, w, 1) + b\n",
    "\n",
    "loss = (y - y_prediction) ** 2\n",
    "train_op = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "\n",
    "    # Training\n",
    "    time_before = time.time()\n",
    "    losses = []  # Storing losses so we can plot them later\n",
    "    for epoch in range(num_epochs):\n",
    "        np.random.shuffle(train_data)\n",
    "        cumulative_loss = 0\n",
    "        for train_x, train_y in train_data:\n",
    "            _loss, _train_op = sess.run(\n",
    "                (loss, train_op), feed_dict={x: train_x, y: train_y})\n",
    "            cumulative_loss += _loss\n",
    "        average_loss = cumulative_loss / len(train_data)\n",
    "        if epoch % 5 == 4:\n",
    "            print('Epoch: {}, Loss: {}'.format(epoch + 1, average_loss))\n",
    "        losses.append(average_loss)\n",
    "    time_after = time.time()\n",
    "    print('Training took {:.2f}s.'.format(time_after - time_before))\n",
    "\n",
    "    # Introspection\n",
    "    print()\n",
    "    _w, _b = sess.run([w, b])\n",
    "    print('Estimated w:', _w)\n",
    "    print('Estimated b:', _b)\n",
    "\n",
    "    # Prediction\n",
    "    train_ys = []\n",
    "    train_ys_prediction = []\n",
    "    for train_x, train_y in train_data:\n",
    "        train_ys.append(train_y)\n",
    "        train_ys_prediction.append(\n",
    "            sess.run(y_prediction, feed_dict={x: train_x}))\n",
    "    train_ys = np.array(train_ys)\n",
    "    train_ys_prediction = np.array(train_ys_prediction)\n",
    "\n",
    "    test_ys = []\n",
    "    test_ys_prediction = []\n",
    "    for test_x, test_y in test_data:\n",
    "        test_ys.append(test_y)\n",
    "        test_ys_prediction.append(sess.run(y_prediction, feed_dict={x: test_x}))\n",
    "    test_ys = np.array(test_ys)\n",
    "    test_ys_prediction = np.array(test_ys_prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(dpi=150)\n",
    "plt.title('Loss over Time')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.plot(range(len(losses)), losses, color='#458588')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mean_squared_error = np.mean((train_ys - train_ys_prediction) ** 2)\n",
    "test_mean_squared_error = np.mean((test_ys - test_ys_prediction) ** 2)\n",
    "\n",
    "print('Mean Squared Error on Training data:', train_mean_squared_error)\n",
    "print('Mean Squared Error on Testing data:', test_mean_squared_error)\n",
    "\n",
    "plt.figure(dpi=150)\n",
    "plt.title('Actual vs Predicted Data Points: Training Set')\n",
    "plt.xlabel('Actual House Price')\n",
    "plt.ylabel('Predicted House Price')\n",
    "plt.plot([min(train_ys), max(train_ys)], [min(train_ys), max(train_ys)],\n",
    "         color='#1D2021', linestyle='--')\n",
    "plt.scatter(train_ys, train_ys_prediction, color='#458588')\n",
    "plt.show()\n",
    "\n",
    "plt.figure(dpi=150)\n",
    "plt.title('Actual vs Predicted Data Points: Testing Set')\n",
    "plt.xlabel('Actual House Price')\n",
    "plt.ylabel('Predicted House Price')\n",
    "plt.plot([min(test_ys), max(test_ys)], [min(test_ys), max(test_ys)],\n",
    "         color='#1D2021', linestyle='--')\n",
    "plt.scatter(test_ys, test_ys_prediction, color='#CC241D')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}