batch_gradient_descent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Age  Temp of Water  Length of Fish\n",
      "0    14             25             620\n",
      "1    28             25            1315\n",
      "2    41             25            2120\n",
      "3    55             25            2600\n",
      "4    69             25            3110\n",
      "5    83             25            3535\n",
      "6    97             25            3935\n",
      "7   111             25            4465\n",
      "8   125             25            4530\n",
      "9   139             25            4570\n",
      "10  153             25            4600\n",
      "11   14             27             625\n",
      "12   28             27            1215\n",
      "13   41             27            2110\n",
      "14   55             27            2805\n",
      "15   69             27            3255\n",
      "16   83             27            4015\n",
      "17   97             27            4315\n",
      "18  111             27            4495\n",
      "19  125             27            4535\n",
      "20  139             27            4600\n",
      "21  153             27            4600\n",
      "22   14             29             590\n",
      "23   28             29            1305\n",
      "24   41             29            2140\n",
      "25   55             29            2890\n",
      "26   69             29            3920\n",
      "27   83             29            3920\n",
      "28   97             29            4515\n",
      "29  111             29            4520\n",
      "30  125             29            4525\n",
      "31  139             29            4565\n",
      "32  153             29            4566\n",
      "33   14             31             590\n",
      "34   28             31            1205\n",
      "35   41             31            1915\n",
      "36   55             31            2140\n",
      "37   69             31            2710\n",
      "38   83             31            3020\n",
      "39   97             31            3030\n",
      "40  111             31            3040\n",
      "41  125             31            3180\n",
      "42  139             31            3257\n",
      "43  153             31            3214\n"
     ]
    }
   ],
   "source": [
    "# Load our matrices and drop our index\n",
    "df = pd.read_csv('x06Simple.csv', header=0)\n",
    "df.drop(df.columns[0], axis=1, inplace=True)\n",
    "print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  14   25  620]\n",
      " [  28   25 1315]\n",
      " [  41   25 2120]\n",
      " [  55   25 2600]\n",
      " [  69   25 3110]\n",
      " [  83   25 3535]\n",
      " [  97   25 3935]\n",
      " [ 111   25 4465]\n",
      " [ 125   25 4530]\n",
      " [ 139   25 4570]\n",
      " [ 153   25 4600]\n",
      " [  14   27  625]\n",
      " [  28   27 1215]\n",
      " [  41   27 2110]\n",
      " [  55   27 2805]\n",
      " [  69   27 3255]\n",
      " [  83   27 4015]\n",
      " [  97   27 4315]\n",
      " [ 111   27 4495]\n",
      " [ 125   27 4535]\n",
      " [ 139   27 4600]\n",
      " [ 153   27 4600]\n",
      " [  14   29  590]\n",
      " [  28   29 1305]\n",
      " [  41   29 2140]\n",
      " [  55   29 2890]\n",
      " [  69   29 3920]\n",
      " [  83   29 3920]\n",
      " [  97   29 4515]\n",
      " [ 111   29 4520]\n",
      " [ 125   29 4525]\n",
      " [ 139   29 4565]\n",
      " [ 153   29 4566]\n",
      " [  14   31  590]\n",
      " [  28   31 1205]\n",
      " [  41   31 1915]\n",
      " [  55   31 2140]\n",
      " [  69   31 2710]\n",
      " [  83   31 3020]\n",
      " [  97   31 3030]\n",
      " [ 111   31 3040]\n",
      " [ 125   31 3180]\n",
      " [ 139   31 3257]\n",
      " [ 153   31 3214]]\n"
     ]
    }
   ],
   "source": [
    "# convert our dataframe into an nparray\n",
    "data = df.to_numpy()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRAIN:\n",
      "[[ 111   27 4495]\n",
      " [  69   27 3255]\n",
      " [  14   29  590]\n",
      " [  83   27 4015]\n",
      " [ 111   31 3040]\n",
      " [ 125   25 4530]\n",
      " [  41   27 2110]\n",
      " [  83   25 3535]\n",
      " [  97   27 4315]\n",
      " [ 153   29 4566]\n",
      " [  55   27 2805]\n",
      " [  41   31 1915]\n",
      " [ 111   25 4465]\n",
      " [  28   31 1205]\n",
      " [  28   25 1315]\n",
      " [  69   29 3920]\n",
      " [  28   27 1215]\n",
      " [  14   31  590]\n",
      " [  41   29 2140]\n",
      " [  97   25 3935]\n",
      " [  28   29 1305]\n",
      " [  55   31 2140]\n",
      " [ 153   27 4600]\n",
      " [ 125   27 4535]\n",
      " [ 139   25 4570]\n",
      " [  97   31 3030]\n",
      " [ 139   31 3257]\n",
      " [  55   25 2600]\n",
      " [  14   25  620]]\n",
      "\n",
      "TEST:\n",
      "[[ 125   29 4525]\n",
      " [  69   31 2710]\n",
      " [  83   29 3920]\n",
      " [  69   25 3110]\n",
      " [ 153   25 4600]\n",
      " [  55   29 2890]\n",
      " [  97   29 4515]\n",
      " [  14   27  625]\n",
      " [  83   31 3020]\n",
      " [ 139   29 4565]\n",
      " [ 111   29 4520]\n",
      " [ 139   27 4600]\n",
      " [ 125   31 3180]\n",
      " [  41   25 2120]\n",
      " [ 153   31 3214]]\n"
     ]
    }
   ],
   "source": [
    "# Split our data into train and test\n",
    "train, test = train_test_split(data, train_size=0.667, random_state=0)\n",
    "print(\"TRAIN:\")\n",
    "print(train)\n",
    "print(\"\\nTEST:\")\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "###\n",
    "### I created this function not for reuse, but for code isolation..\n",
    "### Quick n dirty...\n",
    "### FIXME should probably clean this up\n",
    "###\n",
    "def test_set_rmse(test, thetas, train_x_mean, train_x_std):\n",
    "    total_squared_error = 0\n",
    "    for row in test:\n",
    "\n",
    "        # Normalize our test data based on training data\n",
    "        row_x = row[0:rowlen-1]\n",
    "        row_x_norm = (row_x-train_x_mean) / train_x_std\n",
    "\n",
    "        # Dont forget to add the bias!\n",
    "        row_x_norm = np.append(np.ones(1), row_x_norm)\n",
    "\n",
    "        # Calculate the distance between the predicted vs actual, and sum them up so we can average at end\n",
    "        predicted = (row_x_norm @ thetas)\n",
    "        actual = row[rowlen-1]\n",
    "        error = actual - predicted\n",
    "        total_squared_error += error**2\n",
    "\n",
    "    mse = total_squared_error / test.shape[0]\n",
    "    rmse = math.sqrt(mse)\n",
    "    return rmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training data RMSE:\n",
      "509.38757083323736\n",
      "\n",
      "testing data RMSE:\n",
      "703.6080180379209\n"
     ]
    }
   ],
   "source": [
    "###\n",
    "### Gradient Descent\n",
    "###\n",
    "\n",
    "rowlen = train.shape[1]\n",
    "\n",
    "# Extract the x matrix and standardize\n",
    "# (with range its i:j+1 and with single value its just j... easy to have an off by 1 error with column extraction)\n",
    "train_x = train[:, 0:rowlen-1]\n",
    "\n",
    "# extracted the y column, and convert it back into a single column matrix\n",
    "train_y = train[:, rowlen-1]\n",
    "train_y = train_y.reshape(train_y.shape[0], 1)\n",
    "\n",
    "# Normalize our x training data\n",
    "train_x_mean = np.mean(train_x, axis=0)\n",
    "train_x_std = np.std(train_x, axis=0, ddof=1)\n",
    "train_x_norm = (train_x-train_x_mean) / train_x_std\n",
    "\n",
    "# Add our bias to the training data\n",
    "train_x_norm = np.append(np.ones((train.shape[0], 1)), train_x_norm, 1)\n",
    "\n",
    "# constant learning rate\n",
    "learning_rate = 0.01\n",
    "\n",
    "# init thetas at random from -1 to 1\n",
    "random.seed(a=0)\n",
    "thetas = np.asarray([random.uniform(-1, 1) for i in range(train_x_norm.shape[1])]).reshape((train.shape[1], 1))\n",
    "\n",
    "# These are the arrays for pyplot\n",
    "train_rmses = []\n",
    "test_rmses = []\n",
    "iterations = []\n",
    "\n",
    "# Init our default values\n",
    "iteration = 0\n",
    "prev_rmse = 0\n",
    "rmse_change = 999999\n",
    "\n",
    "# perform the gradient descent\n",
    "while iteration < 1000 and rmse_change > 2**-23:\n",
    "\n",
    "    thetas -= (0.02/train.shape[0]) * train_x_norm.T @ (train_x_norm @ thetas - train_y)\n",
    "\n",
    "    total_squared_error = 0\n",
    "    for i, row_x in enumerate(train_x_norm):\n",
    "        # Calculate the distance between the predicted vs actual, and sum them up so we can average at end\n",
    "        predicted = (row_x @ thetas)\n",
    "        actual = train_y[i]\n",
    "        error = actual - predicted\n",
    "        total_squared_error += error**2\n",
    "\n",
    "    # Calculate our rmse\n",
    "    mse = total_squared_error / train_x_norm.shape[0]\n",
    "    rmse = math.sqrt(mse)\n",
    "\n",
    "    # Book-keeping..\n",
    "    rmse_change = abs(rmse - prev_rmse)\n",
    "    prev_rmse = rmse\n",
    "    iteration += 1\n",
    "\n",
    "    train_rmses.append(rmse)\n",
    "    test_rmses.append(test_set_rmse(test, thetas, train_x_mean, train_x_std))\n",
    "    iterations.append(iteration)\n",
    "\n",
    "print(\"training data RMSE:\")\n",
    "print(rmse)\n",
    "print(\"\\ntesting data RMSE:\")\n",
    "print(test_set_rmse(test, thetas, train_x_mean, train_x_std))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FINAL PREDICTION MODEL:\n",
      "y = 2917.659361805626 + 1221.3321770365553*X1 + -278.69510452956223*X2\n"
     ]
    }
   ],
   "source": [
    "# Print out final model\n",
    "print(\"FINAL PREDICTION MODEL:\")\n",
    "print(\"y = \" + str(thetas[0][0]), end='')\n",
    "for i in range(1, len(thetas)):\n",
    "    print(\" + \" + str(thetas[i][0]) + \"*X\" + str(i), end='')\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "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": [
    "# Finally lets plot our change in RMSE...\n",
    "plt.plot(iterations, train_rmses, color='blue', label='training_data')\n",
    "plt.plot(iterations, test_rmses, color='green', label='test_data')\n",
    "plt.xlabel(\"Iteration #\")\n",
    "plt.ylabel(\"RMSE\")\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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}