Task 2-Supervized Machine Learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Task 2 - To Explore Supervised Machine Learning "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Problem Statement : In this regression task we will predict the percentage of marks that a student is expected to score based upon the number of hours they studied. This is a simple linear regression task as it involves just two variables. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### #Mandatory imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np \n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "pd.set_option(\"display.max_columns\" , None)\n",
    "pd.set_option(\"display.max_rows\" , None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## #Read the file from remote link"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data imported successfully\n"
     ]
    }
   ],
   "source": [
    "data =  \"http://bit.ly/w-data\"\n",
    "student_score = pd.read_csv(data)\n",
    "print(\"Data imported successfully\")"
   ]
  },
  {
   "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>Hours</th>\n",
       "      <th>Scores</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.5</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.1</td>\n",
       "      <td>47</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3.2</td>\n",
       "      <td>27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>8.5</td>\n",
       "      <td>75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>3.5</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Hours  Scores\n",
       "0    2.5      21\n",
       "1    5.1      47\n",
       "2    3.2      27\n",
       "3    8.5      75\n",
       "4    3.5      30"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student_score.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Check null counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hours     0\n",
       "Scores    0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student_score.isnull().sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Plotting the distribution of scores "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "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": [
    "student_score.plot(x = \"Hours\" , y = \"Scores\" , style = \"o\")        #plotting the x and y variable\n",
    "plt.title(\"Hours Vs Percentage\")    #Title of the plot\n",
    "plt.xlabel(\"Hours Studied\")         #title of x-variable\n",
    "plt.ylabel(\"Percentage Score\")      #title of y-variable\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**From the graph above, we can clearly see that there is a positive linear relation between the number of hours studied and percentage of score.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Diving input and output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = student_score.iloc[ :, :-1].values\n",
    "Y = student_score.iloc[ :, 1].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Splitting into train and test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn \n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train , X_test , Y_train , Y_test = train_test_split( X , Y , test_size = 0.2 ,random_state = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Training the algorithm:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Building the model on train data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "reg = LinearRegression()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg.fit(X_train , Y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Plotting the regression line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "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": [
    "line = reg.coef_*X+reg.intercept_  #Formula for line : y = mx + c\n",
    "\n",
    "#Plot for test data\n",
    "plt.scatter(X, Y)\n",
    "plt.plot(X, line , color= \"r\");\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Prediction:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## #Prediction has to be done on test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16.88414476, 33.73226078, 75.357018  , 26.79480124, 60.49103328])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_value = reg.predict(X_test)\n",
    "pred_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Create a dataframe with \"Actual\" and \"Predicted\" values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "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>Actual</th>\n",
       "      <th>Predicted</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>20</td>\n",
       "      <td>16.884145</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>27</td>\n",
       "      <td>33.732261</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>69</td>\n",
       "      <td>75.357018</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>30</td>\n",
       "      <td>26.794801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>62</td>\n",
       "      <td>60.491033</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Actual  Predicted\n",
       "0      20  16.884145\n",
       "1      27  33.732261\n",
       "2      69  75.357018\n",
       "3      30  26.794801\n",
       "4      62  60.491033"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.DataFrame({ \"Actual\" : Y_test   ,\n",
    "                    \"Predicted\" : pred_value})\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No of Hours = [[9.25]]\n",
      "Predicted Score = 93.69173248737538\n"
     ]
    }
   ],
   "source": [
    "# We can also test with our own data\n",
    "hours = np.array([9.25])\n",
    "\n",
    "hours = hours.reshape(-1 , 1)\n",
    "\n",
    "own_pred = reg.predict(hours)\n",
    "\n",
    "print(\"No of Hours = {}\".format(hours))\n",
    "\n",
    "print(\"Predicted Score = {}\".format(own_pred[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #R-square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9515510725211553"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reg.score(X_train, Y_train)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Adjusted R-Square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 1)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R Square value is .... 0.9515510725211553\n",
      "Adjusted R Square value is .... 0.9488594654389974\n"
     ]
    }
   ],
   "source": [
    "k = 1\n",
    "N = 20\n",
    "\n",
    "Rsq= reg.score(X_train, Y_train)\n",
    "\n",
    "AdR_Square= 1- (1-Rsq)*(N-1) / (N-k-1)\n",
    "\n",
    "print(\"R Square value is ....\",Rsq)\n",
    "print(\"Adjusted R Square value is ....\",AdR_Square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# #Model Evaluation------------------------------------------------------------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error: 4.18385989900298\n",
      "Mean Squared Error: 21.598769307217413\n",
      "Root Mean Squared Error: 4.647447612100368\n"
     ]
    }
   ],
   "source": [
    "print('Mean Absolute Error:',  metrics.mean_absolute_error(Y_test, pred_value))\n",
    "\n",
    "print('Mean Squared Error:',  metrics.mean_squared_error(Y_test, pred_value)) \n",
    "\n",
    "print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(Y_test , pred_value))) "
   ]
  },
  {
   "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": 4
}