{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4615f208",
   "metadata": {},
   "source": [
    "### Model Training\n",
    "1.1 Import Data and Required Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bbb5fb5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Basic Import\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt \n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "066470c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modelling\n",
    "from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error\n",
    "from sklearn.neighbors import KNeighborsRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor,AdaBoostRegressor\n",
    "from sklearn.svm import SVR\n",
    "from sklearn.linear_model import LinearRegression, Ridge,Lasso\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from catboost import CatBoostRegressor\n",
    "from xgboost import XGBRegressor\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "41e4a32e",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('studentsperformance.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "19a8f0b4",
   "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>gender</th>\n",
       "      <th>race/ethnicity</th>\n",
       "      <th>parental level of education</th>\n",
       "      <th>lunch</th>\n",
       "      <th>test preparation course</th>\n",
       "      <th>math score</th>\n",
       "      <th>reading score</th>\n",
       "      <th>writing score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>female</td>\n",
       "      <td>group B</td>\n",
       "      <td>bachelor's degree</td>\n",
       "      <td>standard</td>\n",
       "      <td>none</td>\n",
       "      <td>72</td>\n",
       "      <td>72</td>\n",
       "      <td>74</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   gender race/ethnicity parental level of education     lunch  \\\n",
       "0  female        group B           bachelor's degree  standard   \n",
       "\n",
       "  test preparation course  math score  reading score  writing score  \n",
       "0                    none          72             72             74  "
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e9cac137",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop('math score', axis = 1)\n",
    "y = df['math score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "540fab31",
   "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>gender</th>\n",
       "      <th>race/ethnicity</th>\n",
       "      <th>parental level of education</th>\n",
       "      <th>lunch</th>\n",
       "      <th>test preparation course</th>\n",
       "      <th>reading score</th>\n",
       "      <th>writing score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>female</td>\n",
       "      <td>group B</td>\n",
       "      <td>bachelor's degree</td>\n",
       "      <td>standard</td>\n",
       "      <td>none</td>\n",
       "      <td>72</td>\n",
       "      <td>74</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   gender race/ethnicity parental level of education     lunch  \\\n",
       "0  female        group B           bachelor's degree  standard   \n",
       "\n",
       "  test preparation course  reading score  writing score  \n",
       "0                    none             72             74  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.head(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "51144d44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    72\n",
       "Name: math score, dtype: int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.head(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01ee80ae",
   "metadata": {},
   "source": [
    "### Pipeline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "11627557",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Column Transformer with 3 types of transformers\n",
    "num_features = X.select_dtypes(exclude=\"object\").columns\n",
    "cat_features = X.select_dtypes(include=\"object\").columns\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
    "from sklearn.compose import ColumnTransformer\n",
    "\n",
    "numeric_transformer = StandardScaler()\n",
    "oh_transformer = OneHotEncoder()\n",
    "\n",
    "preprocessor = ColumnTransformer(\n",
    "    [\n",
    "        (\"OneHotEncoder\", oh_transformer, cat_features),\n",
    "         (\"StandardScaler\", numeric_transformer, num_features),        \n",
    "    ]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e5d3581d",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = preprocessor.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ba9529a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((800, 19), (200, 19))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# separate dataset into train and test\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.2,random_state=42)\n",
    "X_train.shape, X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8d3fbfa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an Evaluate Function to give all metrics after model Training\n",
    "def evaluate_model(true, predicted):\n",
    "    mae = mean_absolute_error(true, predicted)\n",
    "    mse = mean_squared_error(true, predicted)\n",
    "    rmse = np.sqrt(mse)\n",
    "    r2_square = r2_score(true, predicted)\n",
    "    return mae, rmse, r2_square"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "18928356",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear Regression\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 5.3243\n",
      "- Mean Absolute Error: 4.2671\n",
      "- R2 Score: 0.8743\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 5.3960\n",
      "- Mean Absolute Error: 4.2158\n",
      "- R2 Score: 0.8803\n",
      "===================================\n",
      "\n",
      "\n",
      "Lasso\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 6.5938\n",
      "- Mean Absolute Error: 5.2063\n",
      "- R2 Score: 0.8071\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 6.5197\n",
      "- Mean Absolute Error: 5.1579\n",
      "- R2 Score: 0.8253\n",
      "===================================\n",
      "\n",
      "\n",
      "Ridge\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 5.3233\n",
      "- Mean Absolute Error: 4.2650\n",
      "- R2 Score: 0.8743\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 5.3904\n",
      "- Mean Absolute Error: 4.2111\n",
      "- R2 Score: 0.8806\n",
      "===================================\n",
      "\n",
      "\n",
      "K-Neighbors Regressor\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 5.7077\n",
      "- Mean Absolute Error: 4.5167\n",
      "- R2 Score: 0.8555\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 7.2530\n",
      "- Mean Absolute Error: 5.6210\n",
      "- R2 Score: 0.7838\n",
      "===================================\n",
      "\n",
      "\n",
      "Decision Tree\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 0.2795\n",
      "- Mean Absolute Error: 0.0187\n",
      "- R2 Score: 0.9997\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 7.9066\n",
      "- Mean Absolute Error: 6.3550\n",
      "- R2 Score: 0.7431\n",
      "===================================\n",
      "\n",
      "\n",
      "Random Forest Regressor\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 2.2808\n",
      "- Mean Absolute Error: 1.8341\n",
      "- R2 Score: 0.9769\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 5.9168\n",
      "- Mean Absolute Error: 4.5796\n",
      "- R2 Score: 0.8561\n",
      "===================================\n",
      "\n",
      "\n",
      "XGBRegressor\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 0.9087\n",
      "- Mean Absolute Error: 0.6148\n",
      "- R2 Score: 0.9963\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 6.5889\n",
      "- Mean Absolute Error: 5.0844\n",
      "- R2 Score: 0.8216\n",
      "===================================\n",
      "\n",
      "\n",
      "CatBoosting Regressor\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 3.0427\n",
      "- Mean Absolute Error: 2.4054\n",
      "- R2 Score: 0.9589\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 6.0086\n",
      "- Mean Absolute Error: 4.6125\n",
      "- R2 Score: 0.8516\n",
      "===================================\n",
      "\n",
      "\n",
      "AdaBoost Regressor\n",
      "Model performance for Training set\n",
      "- Root Mean Squared Error: 5.7813\n",
      "- Mean Absolute Error: 4.7602\n",
      "- R2 Score: 0.8517\n",
      "----------------------------------\n",
      "Model performance for Test set\n",
      "- Root Mean Squared Error: 6.0781\n",
      "- Mean Absolute Error: 4.7711\n",
      "- R2 Score: 0.8482\n",
      "===================================\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "models = {\n",
    "    \"Linear Regression\": LinearRegression(),\n",
    "    \"Lasso\": Lasso(),\n",
    "    \"Ridge\": Ridge(),\n",
    "    \"K-Neighbors Regressor\": KNeighborsRegressor(),\n",
    "    \"Decision Tree\": DecisionTreeRegressor(),\n",
    "    \"Random Forest Regressor\": RandomForestRegressor(),\n",
    "    \"XGBRegressor\": XGBRegressor(), \n",
    "    \"CatBoosting Regressor\": CatBoostRegressor(verbose=False),\n",
    "    \"AdaBoost Regressor\": AdaBoostRegressor()\n",
    "}\n",
    "model_list = []\n",
    "r2_list =[]\n",
    "\n",
    "for i in range(len(list(models))):\n",
    "    model = list(models.values())[i]\n",
    "    model.fit(X_train, y_train) # Train model\n",
    "\n",
    "    # Make predictions\n",
    "    y_train_pred = model.predict(X_train)\n",
    "    y_test_pred = model.predict(X_test)\n",
    "    \n",
    "    # Evaluate Train and Test dataset\n",
    "    model_train_mae , model_train_rmse, model_train_r2 = evaluate_model(y_train, y_train_pred)\n",
    "\n",
    "    model_test_mae , model_test_rmse, model_test_r2 = evaluate_model(y_test, y_test_pred)\n",
    "\n",
    "    \n",
    "    print(list(models.keys())[i])\n",
    "    model_list.append(list(models.keys())[i])\n",
    "    \n",
    "    print('Model performance for Training set')\n",
    "    print(\"- Root Mean Squared Error: {:.4f}\".format(model_train_rmse))\n",
    "    print(\"- Mean Absolute Error: {:.4f}\".format(model_train_mae))\n",
    "    print(\"- R2 Score: {:.4f}\".format(model_train_r2))\n",
    "    print('----------------------------------')\n",
    "    \n",
    "    print('Model performance for Test set')\n",
    "    print(\"- Root Mean Squared Error: {:.4f}\".format(model_test_rmse))\n",
    "    print(\"- Mean Absolute Error: {:.4f}\".format(model_test_mae))\n",
    "    print(\"- R2 Score: {:.4f}\".format(model_test_r2))\n",
    "    r2_list.append(model_test_r2)\n",
    "    \n",
    "    print('='*35)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4deaafe9",
   "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>Model Name</th>\n",
       "      <th>R2_Score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Ridge</td>\n",
       "      <td>0.880593</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Linear Regression</td>\n",
       "      <td>0.880345</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Random Forest Regressor</td>\n",
       "      <td>0.856131</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>CatBoosting Regressor</td>\n",
       "      <td>0.851632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>AdaBoost Regressor</td>\n",
       "      <td>0.848181</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Lasso</td>\n",
       "      <td>0.825320</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>XGBRegressor</td>\n",
       "      <td>0.821589</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>K-Neighbors Regressor</td>\n",
       "      <td>0.783813</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Decision Tree</td>\n",
       "      <td>0.743094</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Model Name  R2_Score\n",
       "2                    Ridge  0.880593\n",
       "0        Linear Regression  0.880345\n",
       "5  Random Forest Regressor  0.856131\n",
       "7    CatBoosting Regressor  0.851632\n",
       "8       AdaBoost Regressor  0.848181\n",
       "1                    Lasso  0.825320\n",
       "6             XGBRegressor  0.821589\n",
       "3    K-Neighbors Regressor  0.783813\n",
       "4            Decision Tree  0.743094"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(list(zip(model_list, r2_list)), columns=['Model Name', 'R2_Score']).sort_values(by=[\"R2_Score\"],ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a181133",
   "metadata": {},
   "source": [
    "Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "68b6de4b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Accuracy of the model is 88.03\n"
     ]
    }
   ],
   "source": [
    "lin_model = LinearRegression(fit_intercept=True)\n",
    "lin_model = lin_model.fit(X_train, y_train)\n",
    "y_pred = lin_model.predict(X_test)\n",
    "score = r2_score(y_test, y_pred)*100\n",
    "print(\" Accuracy of the model is %.2f\" %score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8e89547a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot y_pred and y_test\n",
    "\n",
    "plt.scatter(y_test,y_pred);\n",
    "plt.xlabel('Actual');\n",
    "plt.ylabel('Predicted');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0ca263b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.regplot(x=y_test,y=y_pred,ci=None,color ='red');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0af56bc7",
   "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 Value</th>\n",
       "      <th>Predicted Value</th>\n",
       "      <th>Difference</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>521</th>\n",
       "      <td>91</td>\n",
       "      <td>76.507812</td>\n",
       "      <td>14.492188</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>737</th>\n",
       "      <td>53</td>\n",
       "      <td>58.953125</td>\n",
       "      <td>-5.953125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>740</th>\n",
       "      <td>80</td>\n",
       "      <td>76.960938</td>\n",
       "      <td>3.039062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>660</th>\n",
       "      <td>74</td>\n",
       "      <td>76.757812</td>\n",
       "      <td>-2.757812</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>411</th>\n",
       "      <td>84</td>\n",
       "      <td>87.539062</td>\n",
       "      <td>-3.539062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>408</th>\n",
       "      <td>52</td>\n",
       "      <td>43.546875</td>\n",
       "      <td>8.453125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>332</th>\n",
       "      <td>62</td>\n",
       "      <td>62.031250</td>\n",
       "      <td>-0.031250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>208</th>\n",
       "      <td>74</td>\n",
       "      <td>67.976562</td>\n",
       "      <td>6.023438</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>613</th>\n",
       "      <td>65</td>\n",
       "      <td>67.132812</td>\n",
       "      <td>-2.132812</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>78</th>\n",
       "      <td>61</td>\n",
       "      <td>62.492188</td>\n",
       "      <td>-1.492188</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>200 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Actual Value  Predicted Value  Difference\n",
       "521            91        76.507812   14.492188\n",
       "737            53        58.953125   -5.953125\n",
       "740            80        76.960938    3.039062\n",
       "660            74        76.757812   -2.757812\n",
       "411            84        87.539062   -3.539062\n",
       "..            ...              ...         ...\n",
       "408            52        43.546875    8.453125\n",
       "332            62        62.031250   -0.031250\n",
       "208            74        67.976562    6.023438\n",
       "613            65        67.132812   -2.132812\n",
       "78             61        62.492188   -1.492188\n",
       "\n",
       "[200 rows x 3 columns]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_df=pd.DataFrame({'Actual Value':y_test,'Predicted Value':y_pred,'Difference':y_test-y_pred})\n",
    "pred_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "600f220b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2d5caac1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}