notebooks/5_baseline_models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-05-20T12:28:32.643440Z",
     "start_time": "2018-05-20T12:28:32.606527Z"
    }
   },
   "source": [
    "### Baseline models and Feature Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:17:22.894709Z",
     "start_time": "2019-05-29T10:17:21.861851Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import warnings\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "import utils\n",
    "from constants import DATA_DIR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:17:23.874615Z",
     "start_time": "2019-05-29T10:17:23.870707Z"
    }
   },
   "outputs": [],
   "source": [
    "np.random.seed(23)\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Season Average\n",
    "Baseline model - DraftKings shows season average in their data and interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:17:54.270481Z",
     "start_time": "2019-05-29T10:17:31.601951Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "53c6cdf85d3b40c1899d1e62dc807f62",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=141206), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " MAE |  7.472289544657329\n",
      "RMSE |  9.921164051956424\n"
     ]
    }
   ],
   "source": [
    "df_baseline = utils.csv_concatenate(\n",
    "    os.path.join(DATA_DIR, \"Dataframes\", \"Modelling\", \"Baseline\")\n",
    ")\n",
    "df_baseline.sort_values(by=[\"Date\", \"Name\"]).reset_index(drop=True, inplace=True)\n",
    "df_baseline[\"FPTS_pred\"] = utils.calculate_FPTS(df_baseline)\n",
    "\n",
    "# Season average\n",
    "print(\" MAE | \", utils.calculate_MAE(df_baseline[\"FPTS_pred\"], df_baseline[\"FPTS\"]))\n",
    "print(\"RMSE | \", utils.calculate_RMSE(df_baseline[\"FPTS_pred\"], df_baseline[\"FPTS\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:17:57.591992Z",
     "start_time": "2019-05-29T10:17:56.053686Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0f06a22cdc6a49ffbedb36bc02df2966",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.57319, SD: 0.03217\n",
      "RMSE | Mean: 9.85258, SD: 0.04571\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Linear Regression with basic 9 variables counted for fantasy points\n",
    "df_baseline = df_baseline\n",
    "basic = [\"PTS\", \"3P\", \"AST\", \"TRB\", \"STL\", \"BLK\", \"TOV\", \"DD\", \"TD\"]\n",
    "\n",
    "X = df_baseline.loc[:, basic]\n",
    "X = MinMaxScaler().fit_transform(X)\n",
    "y = df_baseline[\"FPTS\"].values.reshape(-1, 1).flatten()\n",
    "\n",
    "reg = LinearRegression()\n",
    "errors = utils.cross_val(reg, X, y, n_folds=5, verbose=0)\n",
    "utils.summarize_errors(errors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-09T13:28:27.367757Z",
     "start_time": "2018-04-09T13:28:27.364972Z"
    }
   },
   "source": [
    "### Weighted Features\n",
    "Choose weighting scheme from linear, square root and quadratic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:18:01.106207Z",
     "start_time": "2019-05-29T10:18:01.102404Z"
    }
   },
   "outputs": [],
   "source": [
    "features = [\n",
    "    \"SG\",\n",
    "    \"F\",\n",
    "    \"C\",\n",
    "    \"PTS\",\n",
    "    \"3P\",\n",
    "    \"AST\",\n",
    "    \"TRB\",\n",
    "    \"STL\",\n",
    "    \"BLK\",\n",
    "    \"TOV\",\n",
    "    \"DD\",\n",
    "    \"TD\",\n",
    "    \"MP\",\n",
    "    \"FT\",\n",
    "    \"FTA\",\n",
    "    \"FGA\",\n",
    "    \"3PA\",\n",
    "    \"DRB\",\n",
    "    \"ORB\",\n",
    "    \"USG_perc\",\n",
    "    \"DRtg\",\n",
    "    \"ORtg\",\n",
    "    \"AST_perc\",\n",
    "    \"DRB_perc\",\n",
    "    \"ORB_perc\",\n",
    "    \"BLK_perc\",\n",
    "    \"TOV_perc\",\n",
    "    \"STL_perc\",\n",
    "    \"eFG_perc\",\n",
    "    \"FG_perc\",\n",
    "    \"3P_perc\",\n",
    "    \"FT_perc\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:18:47.601791Z",
     "start_time": "2019-05-29T10:18:32.373208Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "weighting sheme: sqrt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f6081f9a55b74887856dfb2f4d5a8c0d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.33355, SD: 0.04243\n",
      "RMSE | Mean: 9.61004, SD: 0.06262\n",
      "\n",
      "\n",
      "weighting sheme: linear\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1ad228faeb02463ab94910d3a42d36bd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.30567, SD: 0.04419\n",
      "RMSE | Mean: 9.58473, SD: 0.06456\n",
      "\n",
      "\n",
      "weighting sheme: quad\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "996d3672e2fb478c9c2b8d1c90919870",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.30426, SD: 0.04765\n",
      "RMSE | Mean: 9.59096, SD: 0.06601\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for weighting in [\"sqrt\", \"linear\", \"quad\"]:\n",
    "    print(\"\\nweighting sheme:\", weighting)\n",
    "    df_features = utils.csv_concatenate(\n",
    "        os.path.join(DATA_DIR, \"Dataframes\", \"Modelling\", \"Features\", weighting)\n",
    "    )\n",
    "\n",
    "    X = df_features.loc[:, features]\n",
    "    X = MinMaxScaler().fit_transform(X)\n",
    "    y = df_features[\"FPTS\"].values.reshape(-1, 1).flatten()\n",
    "\n",
    "    reg = LinearRegression()\n",
    "    errors = utils.cross_val(reg, X, y, n_folds=5, verbose=0)\n",
    "    utils.summarize_errors(errors, verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature Selection with Feature Importances"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:19:01.738644Z",
     "start_time": "2019-05-29T10:18:59.661705Z"
    }
   },
   "outputs": [],
   "source": [
    "weighting = \"quad\"\n",
    "df_features = utils.csv_concatenate(\n",
    "    os.path.join(DATA_DIR, \"Dataframes\", \"Modelling\", \"Features\", weighting)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:19:03.216356Z",
     "start_time": "2019-05-29T10:19:03.210322Z"
    }
   },
   "outputs": [],
   "source": [
    "_all = [\n",
    "    \"Salary\",\n",
    "    \"Rest\",\n",
    "    \"Rota_All\",\n",
    "    \"Rota_Pos\",\n",
    "    \"Home\",\n",
    "    \"SG\",\n",
    "    \"F\",\n",
    "    \"C\",\n",
    "    \"Value\",\n",
    "    \"FPTS_std\",\n",
    "    \"PTS\",\n",
    "    \"3P\",\n",
    "    \"AST\",\n",
    "    \"TRB\",\n",
    "    \"STL\",\n",
    "    \"BLK\",\n",
    "    \"TOV\",\n",
    "    \"DD\",\n",
    "    \"TD\",\n",
    "    \"MP\",\n",
    "    \"FT\",\n",
    "    \"FTA\",\n",
    "    \"FGA\",\n",
    "    \"3PA\",\n",
    "    \"DRB\",\n",
    "    \"ORB\",\n",
    "    \"USG_perc\",\n",
    "    \"DRtg\",\n",
    "    \"ORtg\",\n",
    "    \"AST_perc\",\n",
    "    \"DRB_perc\",\n",
    "    \"ORB_perc\",\n",
    "    \"BLK_perc\",\n",
    "    \"TOV_perc\",\n",
    "    \"STL_perc\",\n",
    "    \"eFG_perc\",\n",
    "    \"FG_perc\",\n",
    "    \"3P_perc\",\n",
    "    \"FT_perc\",\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:20:16.663873Z",
     "start_time": "2019-05-29T10:19:06.918377Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = df_features.loc[:, _all]\n",
    "X = MinMaxScaler().fit_transform(X)\n",
    "y = df_features[\"FPTS\"].values.reshape(-1, 1).flatten()\n",
    "\n",
    "# Takes 2 minutes\n",
    "model = GradientBoostingRegressor()\n",
    "model.fit(X, y)\n",
    "\n",
    "top_features = pd.Series(model.feature_importances_, index=_all).sort_values()\n",
    "top_features.plot(kind=\"barh\", figsize=(15, 10), title=\"Top Features\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-04-09T13:29:55.985615Z",
     "start_time": "2018-04-09T13:29:55.982597Z"
    }
   },
   "source": [
    "### Linear Regression with All / Selected Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:21:01.230024Z",
     "start_time": "2019-05-29T10:21:01.224486Z"
    }
   },
   "outputs": [],
   "source": [
    "omit_lowest = 20\n",
    "_selected = list(top_features[omit_lowest:].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-29T10:27:08.213093Z",
     "start_time": "2019-05-29T10:26:40.570798Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "weighting sheme: sqrt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24ce43bdd58c48af8e14b1af1f8c2594",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.28797, SD: 0.04126\n",
      "RMSE | Mean: 9.54591, SD: 0.05979\n",
      "\n",
      "\n",
      "weighting sheme: linear\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3edbb1b5e2fd4444af462fae8fd1c771",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.25764, SD: 0.04189\n",
      "RMSE | Mean: 9.51487, SD: 0.06149\n",
      "\n",
      "\n",
      "weighting sheme: quad\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "39d5023d6fd64f36a957603c0faad644",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.2352, SD: 0.04257\n",
      "RMSE | Mean: 9.49186, SD: 0.06223\n",
      "\n",
      "========================\n",
      "\n",
      "weighting sheme: sqrt\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7ed8418217574fa3a268a899c5b55f63",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.31145, SD: 0.04191\n",
      "RMSE | Mean: 9.57094, SD: 0.06134\n",
      "\n",
      "\n",
      "weighting sheme: linear\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d979523036744f9f82b898ddcbcd7737",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.28358, SD: 0.0426\n",
      "RMSE | Mean: 9.54219, SD: 0.06293\n",
      "\n",
      "\n",
      "weighting sheme: quad\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a4de2c07d23f459dbfa2714fa5967817",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=5), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "   <--- Validation Errors --->\n",
      "MAE  | Mean: 7.26486, SD: 0.0431\n",
      "RMSE | Mean: 9.52171, SD: 0.06373\n",
      "\n",
      "========================\n"
     ]
    }
   ],
   "source": [
    "for feature_type in [_all, _selected]:\n",
    "    for weighting in [\"sqrt\", \"linear\", \"quad\"]:\n",
    "        df_features = utils.csv_concatenate(\n",
    "            os.path.join(DATA_DIR, \"Dataframes\", \"Modelling\", \"Features\", weighting)\n",
    "        )\n",
    "        print(\"\\nweighting sheme: {}\".format(weighting))\n",
    "\n",
    "        X = df_features.loc[:, feature_type]\n",
    "        X = MinMaxScaler().fit_transform(X)\n",
    "        y = df_features[\"FPTS\"].values.reshape(-1, 1).flatten()\n",
    "\n",
    "        reg = LinearRegression()\n",
    "\n",
    "        errors = utils.cross_val(reg, X, y, verbose=0)\n",
    "        utils.summarize_errors(errors, verbose=0)\n",
    "\n",
    "    print(\"========================\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Season Average Baseline\n",
    "- MAE - 7.47229\n",
    "- RMSE - 9.92116\n",
    "\n",
    "### Linear Regression with Additional Features and Quadratic Weighting\n",
    "- MAE  | Mean: 7.2352, SD: 0.04257\n",
    "- RMSE | Mean: 9.49186, SD: 0.06223\n"
   ]
  }
 ],
 "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.1"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}