Linear Regression from scratch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression from scratch\n",
    "\n",
    "A general linear Regression Model.\n",
    "\n",
    "Features Optimization through: \n",
    "\n",
    "- Normal Equation \n",
    "- Gradient Descent with MSE Error \n",
    "\n",
    "Data and Error can be plotted. \n",
    "\n",
    "Note: Datasets that are used are very bad. \n",
    "Gradient Descent normally Leads to better results here since it doesnt calculate perfect tetas on an ill-formed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random \n",
    "import numpy\n",
    "import math \n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data preperation class \n",
    "class data_prep:                                 #Data preparation and normalization for the model \n",
    "    def __init__(self,location):\n",
    "        self.data = open(location, \"r+\")\n",
    "        self.data = self.data.read()\n",
    "        self.data = self.data.splitlines()\n",
    "        \n",
    "    def lNumberizer(self):\n",
    "            count = 0\n",
    "            labels = {}\n",
    "            for x in self.data:\n",
    "                if x[1][0] not in labels:\n",
    "                    labels[x[1][0]] = count\n",
    "                    count+=1\n",
    "            for x in self.data:\n",
    "                x[1] = labels[x[1][0]]\n",
    "            return self.data\n",
    "        \n",
    "    def numberize(self,dataset,toNumberize):\n",
    "        data = numpy.transpose(dataset)\n",
    "        for x in toNumberize: \n",
    "            count= 0 \n",
    "            labels = {}\n",
    "            for z in data[int(x)]:\n",
    "                if z not in labels:\n",
    "                    labels[z] = count\n",
    "                    count+=1\n",
    "            for w in range (len(data[int(x)])):\n",
    "                data[int(x)][w] = labels[data[int(x)][w]]\n",
    "        data = numpy.transpose(data)\n",
    "        data = data.tolist()\n",
    "        return data\n",
    "                       \n",
    "    def transform(self,numbers = \"y\"):\n",
    "        data = self.data\n",
    "        del data[0]\n",
    "        if data[0] == \"\":\n",
    "            del data[0]\n",
    "        self.N = len(data)\n",
    "        for x in range(self.N):\n",
    "            data[x] = data[x].replace(\",\", \"-split-\")\n",
    "            data[x] = data[x].split(\"-split-\")\n",
    "        if numbers == \"n\":\n",
    "            print(\"Please specifiy the features that are not floats. (0 1 4)\")\n",
    "            answer = input().split()\n",
    "            data = self.numberize(data,answer)\n",
    "        for w in range(self.N):\n",
    "            for y in range(len(data[w])):\n",
    "                data[w][y] = float(data[w][y]) \n",
    "        features = len(data[0])-1\n",
    "        labels = []\n",
    "        for x in range(self.N):\n",
    "            labels.append( data[x][features:])\n",
    "            data[x] = data[x][:features]\n",
    "        self.transformedX =numpy.array(data)\n",
    "        self.transformedY = numpy.array(labels)\n",
    "         \n",
    "    def normalize(self):\n",
    "        features = numpy.transpose(self.transformedX)\n",
    "        label = self.transformedY\n",
    "        toDelete = []\n",
    "        for y in range(len(features)):\n",
    "            maxi = max(features[y])\n",
    "            mini = min(features[y])\n",
    "            if maxi == mini: \n",
    "               print(\"Feature \" + str(y) + \" was spotted to be useless (Only 1 possibe value). It will be removed from the dataset\")\n",
    "               toDelete.append(y)\n",
    "            else: \n",
    "                for z in range (len(features[y])):\n",
    "                    features[y][z] =  (features[y][z]- mini)/ (maxi - mini)\n",
    "        newFeatures = []\n",
    "        for z in range(len(features)): \n",
    "            if z not in toDelete: \n",
    "                       newFeatures.append(features[z])\n",
    "        newFeatures = numpy.array(newFeatures)\n",
    "        \n",
    "        maxiy = max(label)\n",
    "        miniy = min(label)\n",
    "        for w in range(len(label)):\n",
    "            label[w] =  (label[w]- miniy)/ (maxiy - miniy)   \n",
    "        newFeatures = numpy.transpose(newFeatures)\n",
    "        self.normalizedY = label\n",
    "        self.normalizedX = newFeatures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "class linear_regressor:\n",
    "    def __init__(self,data,label):\n",
    "        self.X = numpy.expand_dims(data, axis=0)\n",
    "        self.Y = label\n",
    "        self.n = len(data)\n",
    "        self.f = len(data[0])\n",
    "        self.teta = numpy.random.rand(self.f,1)\n",
    "        self.b = numpy.random.rand(1,1)\n",
    "        \n",
    "    def predict_y(self):              # predicts Y with current tetas \n",
    "        predictions = []\n",
    "        for x in range(self.n):\n",
    "            prediction = numpy.dot(self.X[0][x],self.teta) + self.b\n",
    "            predictions.append(prediction[0][0])\n",
    "        return numpy.expand_dims(numpy.array(predictions), axis=0) \n",
    "    \n",
    "    def calc_loss(self):                            #Finds current Loss \n",
    "        predictions = self.predict_y()\n",
    "        MSE = numpy.sum(numpy.subtract(predictions, self.Y)**2) / (self.n*2)\n",
    "        RMSE = math.sqrt(MSE)\n",
    "        return RMSE\n",
    "    \n",
    "    def dLoss(self):                                 # Calcs Gradient based on MSE for Gradient Descent\n",
    "        predictions = self.predict_y()\n",
    "        dtet0 = numpy.sum(numpy.subtract(predictions, self.Y))/(self.n)\n",
    "        dtet1 = numpy.zeros(self.f)\n",
    "        \n",
    "        for x in range(self.n):\n",
    "            prediction = numpy.dot(self.X[0][x],self.teta) + self.b\n",
    "            add = numpy.subtract(prediction[0], self.Y[x])* self.X[0][x]\n",
    "            dtet1 = numpy.add(dtet1,add)\n",
    "        dtet1 = dtet1/self.n\n",
    "        return dtet0, dtet1\n",
    "        \n",
    "    \n",
    "    def gradientDescentLinearRegression(self,alpha=0.00001,iter=50):\n",
    "        print(\"Initial loss: \" + str(self.calc_loss()))    \n",
    "        lossValues = []                                                     # Uses not RMSE but MSE \n",
    "        for x in range(iter):                                               # for gradient. Still works\n",
    "            lossValues.append(self.calc_loss())                           \n",
    "            dteta0, dteta1 = self.dLoss()\n",
    "            self.teta = self.teta - (numpy.transpose(numpy.expand_dims((alpha*dteta1),axis=0  ))) \n",
    "            self.b = numpy.subtract(self.b, (alpha*dteta0))\n",
    "        self.plot_loss(lossValues)\n",
    "        print(\"gradient descent is finnished. The current loss is: \" + str(self.calc_loss()))\n",
    "            \n",
    "    def normalEquation(self):                                 #Optimizes teta based on Normal Equation\n",
    "        print(\"Initial Loss: \" +  str(self.calc_loss()))\n",
    "        bias = numpy.expand_dims(numpy.ones(self.n), axis=0)\n",
    "        X = numpy.transpose(self.X[0])\n",
    "        X = numpy.concatenate((bias,X), axis=0)\n",
    "        X = numpy.transpose(X)\n",
    "        step1 = numpy.dot(numpy.transpose(X), X)\n",
    "        step2 = numpy.linalg.inv(step1) \n",
    "        step3 = numpy.dot(step2,numpy.transpose(X)) \n",
    "        step4 = numpy.dot(step3,self.Y)\n",
    "        self.b= numpy.expand_dims(step4[0],axis=0)\n",
    "        self.teta = step4 [1:]\n",
    "        print(\"Applying the Normal Equation resulted in a loss of: \" + str(self.calc_loss()))\n",
    "        \n",
    "    \n",
    "    def plotFeatures(self,feature):                              #Two features to plot.\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        values = numpy.transpose(self.X[0])\n",
    "        plt.plot(values[feature],self.Y,marker='.',linestyle='none')\n",
    "        plt.title(\"Feature Nr.\" + str(feature) + \" + current regression function\")   \n",
    "        plt.plot(values[feature],(self.teta[feature] * values[feature] + self.b)[0])\n",
    "        plt.show()\n",
    "\n",
    "    def plot_loss(self,loss):\n",
    "        plt.figure(figsize=(8, 8))\n",
    "        plt.plot(loss)\n",
    "        plt.title(\"Loss over time\")   \n",
    "        plt.show()\n",
    "    \n",
    "    def test(self,data,label):                           # Test a new Dataset based on current Model\n",
    "        testFeatures =  numpy.expand_dims(data, axis=0)\n",
    "        testLabels = label\n",
    "        predictions = []\n",
    "        for x in range(len(testFeatures)):\n",
    "            prediction = numpy.dot(testFeatures[0][x],self.teta) + self.b\n",
    "            predictions.append(prediction[0][0])\n",
    "        predictions = numpy.expand_dims(numpy.array(predictions), axis=0)\n",
    "        MSE = numpy.sum(numpy.subtract(predictions, self.Y)**2) / (len(testFeatures[0])*2)\n",
    "        RMSE = math.sqrt(MSE)\n",
    "        print(\"This model has an Error of \" + str(RMSE) + \" on the test Data\")\n",
    "        \n",
    "    \n",
    "\n",
    "            \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data prep:\n",
    "\n",
    "train = data_prep(\"data/Linear/csv/03_train.csv\")\n",
    "train.transform()\n",
    "train.normalize()\n",
    "\n",
    "\n",
    "test = data_prep(\"data/Linear/csv/03_test.csv\")\n",
    "test.transform()\n",
    "test.normalize()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial Loss: 66.95313315934935\n",
      "Applying the Normal Equation resulted in a loss of: 5.821615370317826\n",
      "This model has an Error of 11.043909163999789 on the test Data\n",
      "[[1642.47770041]\n",
      " [ 121.94092144]\n",
      " [ -18.86242408]\n",
      " [-709.24638938]\n",
      " [  16.12296429]\n",
      " [-127.94856764]\n",
      " [1164.35683316]]\n",
      "[[-1022.56892702]]\n"
     ]
    }
   ],
   "source": [
    "Lin = linear_regressor(train.normalizedX,train.normalizedY)\n",
    "Lin.normalEquation()\n",
    "Lin.test(test.normalizedX,test.normalizedY)\n",
    "print(Lin.teta)\n",
    "print(Lin.b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial loss: 80.38129646286494\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gradient descent is finnished. The current loss is: 21.613742117796697\n",
      "This model has an Error of 1.0354771916551126 on the test Data\n",
      "[[0.5134241 ]\n",
      " [0.61748303]\n",
      " [0.61002678]\n",
      " [0.67540332]\n",
      " [0.0826521 ]\n",
      " [0.83135206]\n",
      " [0.1042054 ]]\n",
      "[[-0.65120056]]\n"
     ]
    }
   ],
   "source": [
    "Lin = linear_regressor(train.normalizedX,train.normalizedY)\n",
    "Lin.gradientDescentLinearRegression(iter=50)\n",
    "Lin.test(test.normalizedX,test.normalizedY)\n",
    "print(Lin.teta)\n",
    "print(Lin.b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}