sklearn - Simple Linear Regression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple linear regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import the relevant libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we need NumPy, pandas, matplotlib and seaborn\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "\n",
    "# and of course the actual regression (machine learning) module\n",
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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>SAT</th>\n",
       "      <th>GPA</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1714</td>\n",
       "      <td>2.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1664</td>\n",
       "      <td>2.52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1760</td>\n",
       "      <td>2.54</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1685</td>\n",
       "      <td>2.74</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1693</td>\n",
       "      <td>2.83</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    SAT   GPA\n",
       "0  1714  2.40\n",
       "1  1664  2.52\n",
       "2  1760  2.54\n",
       "3  1685  2.74\n",
       "4  1693  2.83"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We start by loading the data\n",
    "data = pd.read_csv(r'D:\\Stu\\Data Science\\Exercises Regression\\1.01. Simple linear regression.csv')\n",
    "\n",
    "# Let's explore the top 5 rows of the df\n",
    "data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Declare the dependent and independent variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There is a single independent variable: 'SAT'\n",
    "x = data['SAT']\n",
    "\n",
    "# and a single depended variable: 'GPA'\n",
    "y = data['GPA']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(84,)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Often it is useful to check the shapes of the features\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(84,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(84, 1)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In order to feed x to sklearn, it should be a 2D array (a matrix)\n",
    "# Therefore, we must reshape it \n",
    "# Note that this will not be needed when we've got more than 1 feature (as the inputs will be a 2D array by default)\n",
    "\n",
    "# x_matrix = x.values.reshape(84,1)\n",
    "x_matrix = x.values.reshape(-1,1)\n",
    "\n",
    "# Check the shape just in case\n",
    "x_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Regression itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We start by creating a linear regression object\n",
    "reg = LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The whole learning process boils down to fitting the regression\n",
    "# Note that the first argument is the independent variable, while the second - the dependent (unlike with StatsModels)\n",
    "reg.fit(x_matrix,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### R-squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.40600391479679765"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To get the R-squared in sklearn we must call the appropriate method\n",
    "reg.score(x_matrix,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coefficients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.00165569])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting the coefficients of the regression\n",
    "# Note that the output is an array, as we usually expect several coefficients\n",
    "reg.coef_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intercept"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2750402996602803"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting the intercept of the regression\n",
    "# Note that the result is a float as we usually expect a single value\n",
    "reg.intercept_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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>SAT</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1760</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    SAT\n",
       "0  1740\n",
       "1  1760"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To be in line with our knowledge so far, we can create a pandas data frame with several different values of SAT\n",
    "new_data = pd.DataFrame(data=[1740,1760],columns=['SAT'])\n",
    "new_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.15593751, 3.18905127])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can predict the whole data frame in bulk\n",
    "# Note that the result is an array, this time with 2 elements\n",
    "reg.predict(new_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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>SAT</th>\n",
       "      <th>Predicted_GPA</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1740</td>\n",
       "      <td>3.155938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1760</td>\n",
       "      <td>3.189051</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    SAT  Predicted_GPA\n",
       "0  1740       3.155938\n",
       "1  1760       3.189051"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Finally, we can directly store the predictions in a new series of the same dataframe\n",
    "new_data['Predicted_GPA'] = reg.predict(new_data)\n",
    "new_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# There are different ways to plot the data - here's the matplotlib code\n",
    "plt.scatter(x,y)\n",
    "\n",
    "# Parametrized version of the regression line\n",
    "yhat = reg.coef_*x_matrix + reg.intercept_\n",
    "\n",
    "# Non-parametrized version of the regression line\n",
    "#yhat = 0.0017*x + 0.275\n",
    "\n",
    "# Plotting the regression line\n",
    "fig = plt.plot(x,yhat, lw=4, c='orange', label ='regression line')\n",
    "\n",
    "# Labelling our axes\n",
    "plt.xlabel('SAT', fontsize = 20)\n",
    "plt.ylabel('GPA', fontsize = 20)\n",
    "plt.show()"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}