src/Boston_housing_price_regression_dataset_keras_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports\n",
    "\n",
    "`numpy`      package for array handling  \n",
    "`pandas`     import to create and modify dataframes     \n",
    "`matplotlib` package for data visulization  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports \n",
    "import numpy as np \n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading the data\n",
    "Here we are taking the inbuilt function of keras to load the data from the server  \n",
    "The dataset file in present in the [Link to dataset in amazon server](https://s3.amazonaws.com/keras-datasets/boston_housing.npz)  \n",
    "The inbuilt code \n",
    "```python\n",
    "def load_data(path='boston_housing.npz', test_split=0.2, seed=113):\n",
    "    \"\"\"Loads the Boston Housing dataset.\n",
    "    # Arguments\n",
    "        path: path where to cache the dataset locally\n",
    "            (relative to ~/.keras/datasets).\n",
    "        test_split: fraction of the data to reserve as test set.\n",
    "        seed: Random seed for shuffling the data\n",
    "            before computing the test split.\n",
    "    # Returns\n",
    "        Tuple of Numpy arrays: `(x_train, y_train), (x_test, y_test)`.\n",
    "    \"\"\"\n",
    "    assert 0 <= test_split < 1\n",
    "    path = get_file(\n",
    "        path,\n",
    "        origin='https://s3.amazonaws.com/keras-datasets/boston_housing.npz',\n",
    "        file_hash='f553886a1f8d56431e820c5b82552d9d95cfcb96d1e678153f8839538947dff5')\n",
    "    with np.load(path) as f:\n",
    "        x = f['x']\n",
    "        y = f['y']\n",
    "\n",
    "    np.random.seed(seed)\n",
    "    indices = np.arange(len(x))\n",
    "    np.random.shuffle(indices)\n",
    "    x = x[indices]\n",
    "    y = y[indices]\n",
    "\n",
    "    x_train = np.array(x[:int(len(x) * (1 - test_split))])\n",
    "    y_train = np.array(y[:int(len(x) * (1 - test_split))])\n",
    "    x_test = np.array(x[int(len(x) * (1 - test_split)):])\n",
    "    y_test = np.array(y[int(len(x) * (1 - test_split)):])\n",
    "    return (x_train, y_train), (x_test, y_test)\n",
    "```\n",
    "## Regarding Dataset\n",
    "\n",
    "This dataset contains information collected by the U.S Census Service concerning housing in the area of Boston Mass. This dataset contains attributes regarding the housing in boston. There are 506 samples in the dataset.   \n",
    "[official Link](https://www.cs.toronto.edu/~delve/data/boston/bostonDetail.html)   \n",
    "`Line 4` : created a dictionary with respective labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading the dataset\n",
    "from keras.datasets import boston_housing\n",
    "(x_train, y_train), (x_test, y_test) = boston_housing.load_data()\n",
    "columns = ['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B','LSTAT','MEDV']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Understand the dataset\n",
    "Let see the size and shape of test and training tuples\n",
    "\n",
    "``On Execution``  \n",
    "There will be 404 samples of 13 attributes in training set  \n",
    "There will be 102 samples of 13 attributes in testing set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of training samples 404\n",
      "The number of testing samples 102\n",
      "The shape of training samples array (404, 13)\n",
      "The shape of training samples labels (404,)\n"
     ]
    }
   ],
   "source": [
    "404# Understanding the data\n",
    "print(\"The number of training samples\",len(x_train))\n",
    "print(\"The number of testing samples\",len(x_test))\n",
    "print(\"The shape of training samples array\",np.shape(x_train))\n",
    "print(\"The shape of training samples labels\", np.shape(y_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the data\n",
    "Let us try to visualise the few samples of data so, we could get an idea of how the data looks like  \n",
    "`On Execution`  \n",
    "We can see ten images of "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEDV values : [15.2 42.3 50.  21.1 17.7 18.5 11.3 15.6 15.6 14.4]\n"
     ]
    }
   ],
   "source": [
    "# Visualizing the data\n",
    "\n",
    "df = pd.DataFrame(x_train, columns=columns[:-1])\n",
    "df.head()\n",
    "\n",
    "## Labels \n",
    "print(\"{} values :\".format(columns[-1]),y_train[0:10]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preprocessing the data\n",
    "\n",
    "\n",
    "\n",
    "## Normalization\n",
    "We are subtracting the mean of the whole column from the each value and dividing it by standard deviation for every attribute in testing and training sets.\n",
    ">Note: since its a simple dataset there is not much of processing required to attain good accuracies. For all real time datasest preprocessing like normalizing , standadising , on hot encoding, filling the missing values, transforming features, feeding the data in batches and all other type of preprocessing is required\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Preprocessing the data\n",
    "\n",
    "## Normalization\n",
    "mean = x_train.mean(axis=0)        #Train Data\n",
    "std = x_train.std(axis=0)\n",
    "train_data = (x_train - mean) / std\n",
    "\n",
    "mean = y_train.mean(axis=0)        #Train Labels Data\n",
    "std = y_train.std(axis=0)\n",
    "y_train = (y_train - mean) / std\n",
    "\n",
    "mean = x_test.mean(axis=0)        #Test Data\n",
    "std = x_test.std(axis=0)\n",
    "train_data = (x_test - mean) / std\n",
    "\n",
    "mean = y_test.mean(axis=0)        #Test Labels Data\n",
    "std = y_test.std(axis=0)\n",
    "y_test = (y_test - mean) / std"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training varibles\n",
    "These Training varbles are hyper parameters for neural network training.   \n",
    "`epochs` : each epoch is forward propagation + backward propagation over the whole dataset once is called one epoch.  \n",
    "`learning_rate` : the magnitude in which the weights are modified one the acquired loss.   \n",
    "`learning_rate_decay` : there can be high leanring rate at the beining of the training when the loss is high. Over a period of time the learning rate can reduce for fine training of network.  \n",
    "`batch_size` : the data is fed to the network in batches of 32 samples at each time. This batch feeding is done all over the whole dataset.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training varibles\n",
    "learning_rate = 0.0001\n",
    "learning_rate_decay = 0.000001\n",
    "batch_size = 32\n",
    "epochs = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Netowork Model\n",
    "`Line 6` : we are building a keras sequential model  \n",
    "`Line 12` : we are using stochastic gradient decent optimizer  \n",
    "`Line 16` : compiling the model to check if the model is build properly.  \n",
    "\n",
    "The loss function being used is `categorical_crossentropy` since its a multi class classification\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building the model\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense\n",
    "from keras.optimizers import RMSprop\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Dense(64, activation = 'relu',input_shape=(x_train.shape[1],)))\n",
    "model.add(Dense(64, activation = 'relu'))\n",
    "model.add(Dense(1))\n",
    "\n",
    "# Optimizer\n",
    "optimizer = RMSprop(lr=learning_rate, rho=0.9, epsilon=None, decay=learning_rate_decay)\n",
    "\n",
    "# Compiling the model\n",
    "model.compile(loss='mse',optimizer=optimizer,metrics=['mae'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training \n",
    "Training is the process of feeding the data to neural network and modifiying the weights of the model using the the backpropagation algorithm. The backpropagation using loss the function acquires the loss over batch size of data and does a backpropagation to modify the weights in such a way the in the next epoch the loss would be less when compared to the current epoch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 323 samples, validate on 81 samples\n",
      "Epoch 1/20\n",
      "323/323 [==============================] - 1s 2ms/step - loss: 495.8419 - mean_absolute_error: 14.9839 - val_loss: 184.8487 - val_mean_absolute_error: 8.1478\n",
      "Epoch 2/20\n",
      "323/323 [==============================] - 0s 272us/step - loss: 246.5144 - mean_absolute_error: 9.3232 - val_loss: 90.0330 - val_mean_absolute_error: 5.2201\n",
      "Epoch 3/20\n",
      "323/323 [==============================] - 0s 289us/step - loss: 137.0322 - mean_absolute_error: 6.5186 - val_loss: 48.3288 - val_mean_absolute_error: 4.0451\n",
      "Epoch 4/20\n",
      "323/323 [==============================] - 0s 303us/step - loss: 76.8810 - mean_absolute_error: 5.1096 - val_loss: 39.7203 - val_mean_absolute_error: 4.9511\n",
      "Epoch 5/20\n",
      "323/323 [==============================] - 0s 286us/step - loss: 44.9263 - mean_absolute_error: 4.5801 - val_loss: 30.1860 - val_mean_absolute_error: 4.2216\n",
      "Epoch 6/20\n",
      "323/323 [==============================] - 0s 296us/step - loss: 33.7570 - mean_absolute_error: 4.0853 - val_loss: 17.8318 - val_mean_absolute_error: 3.1868\n",
      "Epoch 7/20\n",
      "323/323 [==============================] - 0s 276us/step - loss: 22.3280 - mean_absolute_error: 3.4108 - val_loss: 14.5075 - val_mean_absolute_error: 2.9126\n",
      "Epoch 8/20\n",
      "323/323 [==============================] - 0s 281us/step - loss: 15.5593 - mean_absolute_error: 3.0360 - val_loss: 24.1158 - val_mean_absolute_error: 3.8880\n",
      "Epoch 9/20\n",
      "323/323 [==============================] - 0s 293us/step - loss: 12.2634 - mean_absolute_error: 2.6447 - val_loss: 12.0324 - val_mean_absolute_error: 2.5145\n",
      "Epoch 10/20\n",
      "323/323 [==============================] - 0s 290us/step - loss: 8.4836 - mean_absolute_error: 2.2798 - val_loss: 9.2251 - val_mean_absolute_error: 2.2455\n",
      "Epoch 11/20\n",
      "323/323 [==============================] - 0s 296us/step - loss: 8.5885 - mean_absolute_error: 2.2807 - val_loss: 7.1153 - val_mean_absolute_error: 1.9840\n",
      "Epoch 12/20\n",
      "323/323 [==============================] - 0s 271us/step - loss: 6.1673 - mean_absolute_error: 1.9136 - val_loss: 10.7192 - val_mean_absolute_error: 2.5198\n",
      "Epoch 13/20\n",
      "323/323 [==============================] - 0s 308us/step - loss: 6.1136 - mean_absolute_error: 1.9273 - val_loss: 6.1826 - val_mean_absolute_error: 2.0573\n",
      "Epoch 14/20\n",
      "323/323 [==============================] - 0s 300us/step - loss: 6.8820 - mean_absolute_error: 2.0314 - val_loss: 11.7942 - val_mean_absolute_error: 2.7600\n",
      "Epoch 15/20\n",
      "323/323 [==============================] - 0s 295us/step - loss: 5.9351 - mean_absolute_error: 1.8457 - val_loss: 4.6282 - val_mean_absolute_error: 1.5898\n",
      "Epoch 16/20\n",
      "323/323 [==============================] - 0s 311us/step - loss: 5.2465 - mean_absolute_error: 1.7748 - val_loss: 6.3384 - val_mean_absolute_error: 1.8869\n",
      "Epoch 17/20\n",
      "323/323 [==============================] - 0s 323us/step - loss: 4.9185 - mean_absolute_error: 1.7065 - val_loss: 10.0894 - val_mean_absolute_error: 2.5314\n",
      "Epoch 18/20\n",
      "323/323 [==============================] - 0s 346us/step - loss: 4.8811 - mean_absolute_error: 1.7071 - val_loss: 3.6228 - val_mean_absolute_error: 1.4045\n",
      "Epoch 19/20\n",
      "323/323 [==============================] - 0s 264us/step - loss: 3.5973 - mean_absolute_error: 1.4179 - val_loss: 8.5390 - val_mean_absolute_error: 2.5523\n",
      "Epoch 20/20\n",
      "323/323 [==============================] - 0s 257us/step - loss: 4.5475 - mean_absolute_error: 1.6993 - val_loss: 3.8140 - val_mean_absolute_error: 1.4340\n"
     ]
    }
   ],
   "source": [
    "# Training\n",
    "model_history = model.fit(x_train, y_train, epochs=epochs,validation_split=0.2, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results\n",
    "using the trained model we try to predict what are the values of target label in the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "102/102 [==============================] - 0s 607us/step\n"
     ]
    }
   ],
   "source": [
    "# Results\n",
    "y_pred = model.predict(x=x_test, batch_size=batch_size, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Verifying the results\n",
    "cheking the results how good they are with the first 10 samples.   \n",
    "Plotting the graphs of test and train set accuracies and loss values. \n",
    "> NOTE: This plot is a very curicial step. These plots would tell us how good the model converges and if there is any overfitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ground truths of first 10 images in test set [-1.74032966 -0.46893052 -0.44700984  0.42981715 -0.09627904  0.15580872\n",
      "  0.89015133 -0.01955668 -0.28260478  0.01332433]\n",
      "Predicted values of first 10 image in test set [0 0 0 0 0 0 0 0 0 0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Verifying the results\n",
    "print(\"Ground truths of first 10 images in test set\",np.array(y_test[0:10]))\n",
    "print(\"Predicted values of first 10 image in test set\",np.argmax(y_pred[0:10],axis=1))\n",
    "\n",
    "loss = model_history.history['loss']\n",
    "val_loss = model_history.history['val_loss']\n",
    "plt.plot(loss,label='train')\n",
    "plt.plot(val_loss,label='test')\n",
    "plt.title('loss Graph')\n",
    "plt.ylabel('value')\n",
    "plt.xlabel('epochs')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "acc = model_history.history['mean_absolute_error']\n",
    "val_acc = model_history.history['val_mean_absolute_error']\n",
    "plt.plot(acc,label='train')\n",
    "plt.plot(val_acc,label='test')\n",
    "plt.title('mean_absolute_error Graph')\n",
    "plt.ylabel('value')\n",
    "plt.xlabel('epochs')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}