Linear_Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Regression\n",
    "\n",
    "Linear Regression is a statistical technique that model a relationship between two variable. These two variables are independent (explanotary) and depended-variable. Independent variables(response) can't be controlled, they need to be estimated or predicted. The depended variable is controllable as it is input value.\n",
    "\n",
    "**The goal in regression problems is to predict the value of a continuous independed variable**\n",
    "\n",
    "**Example:** Suppose you wish to know the price of a pizza. But we have machine learning book, so we will use simple linear regression to predict the price of a pizza based on an attribute of the pizza that we can observe. Let's model the relationship between the size of a pizza and its price.\n",
    "\n",
    "\n",
    "|Diameter (inc)|Price ($)|\n",
    "|---|---|\n",
    "|6|7|\n",
    "|8|9|\n",
    "|10|13|\n",
    "|14|17.5|\n",
    "|18|18|\n",
    "\n",
    "* We can visualize our training data by plotting it on a graph using matplotlib\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#import the matplot\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "sns.set()\n",
    "#define the data #reshape for one varibale\n",
    "X = np.array([6,8,10,14,18]).reshape(-1,1)\n",
    "y = np.array([7,9,13,17.5,18]).reshape(-1,1)\n",
    "\n",
    "plt.xlabel('Diameter in inches')\n",
    "plt.ylabel('Pizza price plotted against diameter')\n",
    "plt.title('Pizza price plotted against diameter')\n",
    "plt.plot(X,y,'k.')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let'r create our model\n",
    "from sklearn.linear_model import  LinearRegression\n",
    "model = LinearRegression()\n",
    "model.fit(X,y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7.82327586]\n",
      " [ 9.77586207]\n",
      " [11.72844828]\n",
      " [15.63362069]\n",
      " [19.5387931 ]]\n"
     ]
    }
   ],
   "source": [
    "print(model.predict(X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.9762931]]\n"
     ]
    }
   ],
   "source": [
    "print(model.coef_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9100015964240102\n"
     ]
    }
   ],
   "source": [
    "print(model.score(X,y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_inc(x):\n",
    "    \"\"\"Find the price for a given diameter value\"\"\"\n",
    "    #y = mx + b\n",
    "    find_y = model.coef_ * x + model.intercept_\n",
    "    return np.round(find_y,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[13.68]]\n"
     ]
    }
   ],
   "source": [
    "print(find_inc(12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fit method of LinearRegression learns the parameters of the following model for simple linear regression:\n",
    "$y =\\beta x +  \\alpha  $ y is the predicted value of the response variable(or independed variable); in this example, it is the predicted price of the pizza. x is the explanatory variable(depended-variable). The intercept  $\\alpha$ term  and $\\beta$ coefficient are parameters of the model that are learned by the learning algorithm.\n",
    "\n",
    "We need to find out that our model quality. For this, we use the loss function also called cost function.  This function is the calculated sum of the squared residuals. Residuals are defined with the differences between the predicted values by the observed values in the training data set. \n",
    "\n",
    "* In statistics, this function called in different ways \n",
    "    * Residual sum of squares(RSS)\n",
    "    * Sum of squared residual (SSR)\n",
    "    * Sum of squared estimated of error(SSE)\n",
    "    \n",
    "    \n",
    "$$RSS = \\sum_{i=1}^{n}({y_i - f(x_i)})^2 $$\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7495689655172406\n"
     ]
    }
   ],
   "source": [
    "RSS = np.mean((model.predict(X) - y) ** 2)\n",
    "print(RSS)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now that we have a cost function, we can find the values of our model's parameters that minimize it. $\\beta$ and $\\alpha$ minimize the cost function. We will solve $\\bate$ first. To do so, we will calculate the *variance* of x and *covariance* of x and y.\n",
    "\n",
    "\n",
    "* *Variance* is a measure of how far a set of values is spread out. Variance can be calculated using the following equation: \n",
    "\n",
    "$$var(x) = \\frac{\\sum_{i=1}^{n}(x_i - \\bar{x} )^2 }{n-1}$$\n",
    "\n",
    "* $\\bar{x}$ is the mean of the x\n",
    "* $x_i$ is the value of x for the $i^th$ training instance\n",
    "* n is the number of training instances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.2\n",
      "23.2\n"
     ]
    }
   ],
   "source": [
    "#Let's calculate the variance ofor\n",
    "x = [[6,8,10,14,18]]\n",
    "x_mean = np.mean(x)\n",
    "variance = np.sum([(i - x_mean)**2 for i in x])/4\n",
    "print(variance)\n",
    "#there is also numpy methot the calculate the variance\n",
    "#The ddof keyword parameter can be used to set Bessel's correction to calculate the sample variance:\n",
    "print(np.var(x, ddof=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Covariance** is a measure of how much two variables change together. If the value of\n",
    "the variables increase together, their covariance is positive. If one variable tends to\n",
    "increase while the other decreases, their covariance is negative. If there is no linear\n",
    "relationship between the two variables, their covariance will be equal to zero; the\n",
    "variables are linearly uncorrelated but not necessarily independent. Covariance can\n",
    "be calculated using the following formula:\n",
    "\n",
    "$$cov(x,y) = \\frac{\\sum_{i=1}^{n}(x_i - \\bar{x})(y_i - \\bar{y})}{n-1} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.65\n",
      "22.650000000000002\n"
     ]
    }
   ],
   "source": [
    "y_cov =[[7,9,13,17.5,18]]\n",
    "y_mean = np.mean(y_cov)\n",
    "\n",
    "cov = np.sum([[(i - x_mean)*(j- y_mean) for i in x] for j in y_cov])/4\n",
    "print(cov)\n",
    "\n",
    "#there is numpy method for covariance\n",
    "\n",
    "print(np.cov(x,y_cov)[0][1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have calculated the variance of our explanatory variable and the covariance of the response and explanatory variables, we can solve $\\beta$ using the following formula:\n",
    "\n",
    "$$\\beta = \\frac{cov(x,y)}{var(x)}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9762931034482758\n"
     ]
    }
   ],
   "source": [
    "#Let's calculate the beta\n",
    "beta = cov / variance\n",
    "print(beta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We can solve $\\alpha$ using the following formula: \n",
    "$$\\alpha = \\bar{y} -\\beta \\bar{x} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9655172413793114\n"
     ]
    }
   ],
   "source": [
    "alpha = y_mean - beta * x_mean\n",
    "print(alpha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def price_expect(x):\n",
    "    result = beta * x + alpha\n",
    "    return round(result, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.7\n"
     ]
    }
   ],
   "source": [
    "print(price_expect(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.68\n"
     ]
    }
   ],
   "source": [
    "print(price_expect(12))"
   ]
  },
  {
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}