LinearReg.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LinearReg  Test\n",
    "***\n",
    "In this notebook, I'll try to use my linear regression implementation (LinearReg) over a simple 2-features dataset\n",
    "\n",
    "First of all, we import:\n",
    "1. *numpy* for linear algebra (matrix handling) though it's not required, it's already imported by LinearReg\n",
    "2. *matplotlib.pyplot* to do some plotting and see the results\n",
    "3. *pandas* to load the data from a csv file\n",
    "4. *LinearReg* (personal implementation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from LinearReg import LinearReg as lr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using pandas we'll load our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv('./datasets/LinearReg.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see how it looks like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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>ID</th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0.0000</td>\n",
       "      <td>5.59209</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>0.4450</td>\n",
       "      <td>6.13800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>0.6230</td>\n",
       "      <td>6.69600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1.2727</td>\n",
       "      <td>6.78900</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ID       x        y\n",
       "0   0  0.0000  5.59209\n",
       "1   1  0.4450  6.13800\n",
       "2   2  0.6230  6.69600\n",
       "3   3  1.2727  6.78900"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For better insight and since the data consists of one feature only, we can plot it and see how y varies according to x, to do so, first we convert our DataFrame to a numpy array (cutting the ID column) and then plot using *pyplot*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.       0.445    0.623    1.2727   1.78     2.225    2.67     3.115\n",
      " 3.56     4.005    4.45     4.895    5.34     5.251    6.4347   6.675\n",
      " 6.7284   0.       0.445    0.89     1.335    1.78     2.225    3.026\n",
      " 3.115    3.56     3.649    4.45     5.2243   5.34     5.645626 6.23\n",
      " 6.43826  7.12     0.       0.445    0.89     1.335    1.78     2.225\n",
      " 2.67     3.115    3.56     4.005    4.45     4.895    4.8327   5.9363\n",
      " 6.23     6.497    7.12    ]\n",
      "[ 5.59209  6.138    6.696    6.789    7.533    7.905    8.463    8.69085\n",
      "  9.3093   9.9231  10.3416  11.16    11.532   11.625   12.10116 12.834\n",
      " 14.1639   5.3661   5.8311   6.2961   6.7611   7.2261   7.6911   8.1561\n",
      "  8.6211   9.0861   9.5511  10.0161  10.4811  10.9461  11.4111  11.8761\n",
      " 12.3411  12.8061   5.59209  6.138    6.696    6.789    7.533    7.8585\n",
      "  8.463    8.69085  9.5976   9.9231  10.3416  11.16    11.532   11.625\n",
      " 12.10116 12.4899  14.1639 ]\n"
     ]
    }
   ],
   "source": [
    "np_data = data.to_numpy()\n",
    "inp = np_data[:, 1] # 2nd colunm\n",
    "out = np_data[:, 2] # 3rd column\n",
    "print(inp) \n",
    "print(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 880x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(11, 6), dpi=80, facecolor='#e1e1e1')\n",
    "ax = fig.add_subplot(111)\n",
    "ax.set_facecolor('#1d1d1d')\n",
    "\n",
    "ax.scatter(inp, out, marker='x', c='w', s=100)\n",
    "\n",
    "plt.ylim((2, 16))\n",
    "plt.xlim((0, 8))\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can easily observe, the data can be fit with a linear function, to train our model, first we'll need to add the bias column:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(51, 2)\n",
      "[[1.     0.    ]\n",
      " [1.     0.445 ]\n",
      " [1.     0.623 ]\n",
      " [1.     1.2727]\n",
      " [1.     1.78  ]]\n"
     ]
    }
   ],
   "source": [
    "X = inp.reshape(-1, 1) # make matrix\n",
    "X = np.insert(X, [0], 1, axis=1) # add bias ~ 1 feature\n",
    "y = out\n",
    "\n",
    "print(X.shape)\n",
    "print(X[:5, :]) # see the bias ~ column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we create a *LinearReg* model and fit the data, the solver uses stochastic gradient-descent though you can set a custom batch_size i.e. to use full gradient-descent you can just set batch_size to the number of samples in the training data (X.shape[0] here):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration  0  error =  42.96025663526839\n",
      "iteration  1  error =  39.77319435277572\n",
      "iteration  2  error =  36.82402651637168\n",
      "iteration  3  error =  34.09493208256782\n",
      "iteration  4  error =  31.56942866077218\n",
      "iteration  5  error =  29.232271749990137\n",
      "iteration  6  error =  27.069361572070676\n",
      "iteration  7  error =  25.067656928120467\n",
      "iteration  8  error =  23.215095548022877\n",
      "iteration  9  error =  21.500520443041385\n",
      "iteration  10  error =  19.913611808502022\n",
      "iteration  11  error =  18.444824057765832\n",
      "iteration  12  error =  17.085327600333002\n",
      "iteration  13  error =  15.826955006160683\n",
      "iteration  14  error =  14.66215122530588\n",
      "iteration  15  error =  13.583927556992135\n",
      "iteration  16  error =  12.585819085297475\n",
      "iteration  17  error =  11.661845320014013\n",
      "iteration  18  error =  10.806473800969849\n",
      "iteration  19  error =  10.014586442351163\n",
      "iteration  20  error =  9.28144841043221\n",
      "iteration  21  error =  8.602679343715511\n",
      "iteration  22  error =  7.974226738900905\n",
      "iteration  23  error =  7.392341339429737\n",
      "iteration  24  error =  6.853554375670954\n",
      "iteration  25  error =  6.354656517205805\n",
      "iteration  26  error =  5.892678408197616\n",
      "iteration  27  error =  5.4648726665671585\n",
      "iteration  28  error =  5.06869723669349\n",
      "iteration  29  error =  4.701799993679589\n",
      "iteration  30  error =  4.362004504913242\n",
      "iteration  31  error =  4.047296861764219\n",
      "iteration  32  error =  3.7558135008324314\n",
      "iteration  33  error =  3.485829940238749\n",
      "iteration  34  error =  3.2357503620689165\n",
      "iteration  35  error =  3.0040979772751473\n",
      "iteration  36  error =  2.7895061141421555\n",
      "iteration  37  error =  2.5907099758642165\n",
      "iteration  38  error =  2.406539016884395\n",
      "iteration  39  error =  2.2359098914419575\n",
      "iteration  40  error =  2.077819931282503\n",
      "iteration  41  error =  1.9313411127290196\n",
      "iteration  42  error =  1.795614476311055\n",
      "iteration  43  error =  1.6698449649220044\n",
      "iteration  44  error =  1.5532966490379057\n",
      "iteration  45  error =  1.445288309901434\n",
      "iteration  46  error =  1.3451893537660686\n",
      "iteration  47  error =  1.2524160323215754\n",
      "iteration  48  error =  1.1664279462951967\n",
      "iteration  49  error =  1.0867248109550558\n",
      "iteration  50  error =  1.0128434638436195\n",
      "iteration  51  error =  0.9443550965498718\n",
      "iteration  52  error =  0.8808626936978563\n",
      "iteration  53  error =  0.8219986635951371\n",
      "iteration  54  error =  0.7674226461552044\n",
      "iteration  55  error =  0.7168194847900629\n",
      "iteration  56  error =  0.6698973499699784\n",
      "iteration  57  error =  0.6263860030726157\n",
      "iteration  58  error =  0.5860351899993858\n",
      "iteration  59  error =  0.5486131548279577\n",
      "iteration  60  error =  0.513905264501404\n",
      "iteration  61  error =  0.48171273623089517\n",
      "iteration  62  error =  0.4518514599143589\n",
      "iteration  63  error =  0.4241509084519007\n",
      "iteration  64  error =  0.3984531293736392\n",
      "iteration  65  error =  0.3746118116902006\n",
      "iteration  66  error =  0.3524914223334603\n",
      "iteration  67  error =  0.33196640697806673\n",
      "iteration  68  error =  0.31292045042538297\n",
      "iteration  69  error =  0.29524579209316254\n",
      "iteration  70  error =  0.2788425924887559\n",
      "iteration  71  error =  0.26361834685294855\n",
      "iteration  72  error =  0.24948734244757478\n",
      "iteration  73  error =  0.23637015622460456\n",
      "iteration  74  error =  0.22419318985902903\n",
      "iteration  75  error =  0.212888239354139\n",
      "iteration  76  error =  0.20239209663703628\n",
      "iteration  77  error =  0.1926461807557338\n",
      "iteration  78  error =  0.18359619646818914\n",
      "iteration  79  error =  0.17519181817914423\n",
      "iteration  80  error =  0.16738639733375027\n",
      "iteration  81  error =  0.16013669151854368\n",
      "iteration  82  error =  0.1534026136513254\n",
      "iteration  83  error =  0.14714699976261375\n",
      "iteration  84  error =  0.1413353939833915\n",
      "iteration  85  error =  0.13593584945749587\n",
      "iteration  86  error =  0.13091874399286052\n",
      "iteration  87  error =  0.12625660935447844\n",
      "iteration  88  error =  0.12192397318397061\n",
      "iteration  89  error =  0.1178972126065095\n",
      "iteration  90  error =  0.11415441865601768\n",
      "iteration  91  error =  0.11067527071448115\n",
      "iteration  92  error =  0.10744092022126044\n",
      "iteration  93  error =  0.10443388296383471\n",
      "iteration  94  error =  0.10163793931280328\n",
      "iteration  95  error =  0.09903804181150301\n",
      "iteration  96  error =  0.09662022957458326\n",
      "iteration  97  error =  0.09437154899056305\n",
      "iteration  98  error =  0.09227998026103823\n",
      "iteration  99  error =  0.09033436934402915\n",
      "iteration  100  error =  0.08852436490117861\n",
      "iteration  101  error =  0.08684035987831902\n",
      "iteration  102  error =  0.08527343737650607\n",
      "iteration  103  error =  0.08381532049613775\n",
      "iteration  104  error =  0.0824583258603847\n",
      "iteration  105  error =  0.08119532054600814\n",
      "iteration  106  error =  0.080019682169852\n",
      "iteration  107  error =  0.07892526189800815\n",
      "iteration  108  error =  0.07790635016195403\n",
      "iteration  109  error =  0.07695764488198617\n",
      "Convergence!\n",
      "training_accuracy =  0.7813309548613566 average distance =  0.28479545816294155\n"
     ]
    }
   ],
   "source": [
    "model = lr().fit(X, y, verbose=1, tol=1e-3, learning_rate=0.11, regularization_rate=0, max_iter=1000,\n",
    "                batch_size = X.shape[0])\n",
    "training_accuracy, d_avg = model.score(X, y, tol=0.8)\n",
    "print('training_accuracy = ', training_accuracy, 'average distance = ', d_avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The LinearReg.score(X, y, tol) function compute the accuracy based on the average tolerable amount of distance between the predicted values and the original ones (in y), if the (average distance = tol) then the accuracy will be 0.5, if the average distance is 0 the accuracy will take 1 (well fit), said that way, the function we seek is surely involving and exp() expression, I've come up with this function, fist we compute the average distance between the predictions (y_p) and the real values (y):\n",
    "***\n",
    "\\begin{equation*}\n",
    "d_{avg} =  \\frac {\\sum_{i=1}^m |y_p[i] - y[i]|} {m}\n",
    "\\end{equation*}\n",
    "***\n",
    "Then we compute the precision ( of tolerance *tol* ) using:\n",
    "***\n",
    "\\begin{equation*}\n",
    "P_{tol} = exp(\\frac{-ln(2) * d_{avg} } {tol})\n",
    "\\end{equation*}\n",
    "***\n",
    "Remark that if *d_avg* is equal to *tol* then:\n",
    "\n",
    "\\begin{equation*}\n",
    "P_{tol} = e^{-ln2} = \\frac{1} {e^{ln2}} = \\frac{1}{2} = 0.5\n",
    "\\end{equation*}\n",
    "***\n",
    "\n",
    "**m**: the number of samples to score over.\n",
    "\n",
    "Next we plot our model since it's a 1-feature only then we can easily do it: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_range = np.arange(0, 8, 0.1) # 2 points would be enough since it's linear but it's okay\n",
    "x_featured = np.insert(x_range.reshape(-1, 1), [0], 1, axis=1) # insert bias to predict\n",
    "y_range = model.predict(x_featured)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 880x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(11, 6), dpi=80, facecolor='#e1e1e1')\n",
    "ax = fig.add_subplot(111)\n",
    "ax.set_facecolor('#1d1d1d')\n",
    "\n",
    "ax.scatter(inp, out, marker='x', c='w', s=100)\n",
    "ax.scatter(x_range, y_range, marker='.', c='w')\n",
    "\n",
    "plt.ylim((2, 16))\n",
    "plt.xlim((0, 8))\n",
    "\n",
    "plt.grid(color='#313131')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Useful Links\n",
    "***\n",
    "\n",
    "1. [Wikipedia's Linear Regression Article](https://en.wikipedia.org/wiki/Linear_regression)\n",
    "2. [Coursera Andrew Ng's Machine Learning Course ~ Week 1 & 2](https://www.coursera.org/)\n",
    "3. [Wikipedia's Gradient Descent Article](https://en.wikipedia.org/wiki/Gradient_descent)\n"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}