{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e8097196-a89e-402c-9ab7-3bd28201f791",
   "metadata": {},
   "source": [
    "# ![](https://ga-dash.s3.amazonaws.com/production/assets/logo-9f88ae6c9c3871690e33280fcf557f33.png) Capstone Project\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdc1ccd8-264c-4f79-8b17-65d01ac92a81",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### [Capstone Project, Part 1: Proposal](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part1-proposal.ipynb)\n",
    "#### [Capstone Project, Part 2: Brief](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part2-brief.ipynb)\n",
    "- [Writing data to MongoDB](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part2-brief.ipynb#mongo_db)\n",
    "- [Data Dictionary](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part2-brief.ipynb#data_dictionary)\n",
    "- [Map of races around the world](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part2-brief.ipynb#world-map)\n",
    "\n",
    "#### [Capstone Project, Part 3: Technical Notebook](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb)\n",
    "- [Feature Engineering](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#feature_eng)\n",
    "- [Regression Approaches](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#regression_approaches)\n",
    "- [Classification Approaches](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#classification_approaches)\n",
    "- [Feature Importance](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#feature_importance)\n",
    "- [Feature Selection](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#feature_selection)\n",
    "- [Models Comparison](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part3-technical-notebook.ipynb#models_comparison)\n",
    "\n",
    "#### [Capstone Project, Part 4: Presentation](https://61c08c5e1627a3416b0c37b4--pensive-nobel-d54f9f.netlify.app/)\n",
    "#### [Capstone Project, Part 5: Appendix](https://nbviewer.org/github/jaeyow/f1-predictor/blob/main/final-project-part5-appendix.ipynb)\n",
    "\n",
    "#### [Capstone Project, Part 6: MLOps](https://github.com/jaeyow/f1-predictor/blob/main/.github/workflows/f1-mlops.yml)\n",
    "Using GitHub Actions as a cheap (and free) MLOps tool alternative: - invoke MLOps workflow on-demand (or with a cron schedule)\n",
    "- get latest source\n",
    "- setup Python build/MLOps environment\n",
    "- data retrieval and preparation\n",
    "- feature engineering\n",
    "- preparation for model training (including dummify categorical features)\n",
    "- feature selection\n",
    "- model building and scoring\n",
    "- setup serverless (lambda) API in AWS\n",
    "- deploy model to serverless API\n",
    "- profit!\n",
    "\n",
    "![](./images/f1-mclaren-car.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2a8d2696-3532-40a5-b8d1-0bc966315cd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pandas in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (1.3.5)\n",
      "Requirement already satisfied: python-dateutil>=2.7.3 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from pandas) (2.8.2)\n",
      "Requirement already satisfied: numpy>=1.17.3 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from pandas) (1.21.5)\n",
      "Requirement already satisfied: pytz>=2017.3 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from pandas) (2021.3)\n",
      "Requirement already satisfied: six>=1.5 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from python-dateutil>=2.7.3->pandas) (1.16.0)\n",
      "Collecting matplotlib\n",
      "  Downloading matplotlib-3.5.1-cp38-cp38-macosx_10_9_x86_64.whl (7.3 MB)\n",
      "\u001b[K     |████████████████████████████████| 7.3 MB 640 kB/s eta 0:00:01\n",
      "\u001b[?25hCollecting cycler>=0.10\n",
      "  Downloading cycler-0.11.0-py3-none-any.whl (6.4 kB)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from matplotlib) (3.0.4)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from matplotlib) (2.8.2)\n",
      "Requirement already satisfied: numpy>=1.17 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from matplotlib) (1.21.5)\n",
      "Collecting pillow>=6.2.0\n",
      "  Downloading Pillow-8.4.0-cp38-cp38-macosx_10_10_x86_64.whl (3.0 MB)\n",
      "\u001b[K     |████████████████████████████████| 3.0 MB 309 kB/s eta 0:00:01\n",
      "\u001b[?25hCollecting kiwisolver>=1.0.1\n",
      "  Downloading kiwisolver-1.3.2-cp38-cp38-macosx_10_9_x86_64.whl (61 kB)\n",
      "\u001b[K     |████████████████████████████████| 61 kB 560 kB/s eta 0:00:01\n",
      "\u001b[?25hCollecting fonttools>=4.22.0\n",
      "  Downloading fonttools-4.28.5-py3-none-any.whl (890 kB)\n",
      "\u001b[K     |████████████████████████████████| 890 kB 593 kB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: packaging>=20.0 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from matplotlib) (21.3)\n",
      "Requirement already satisfied: six>=1.5 in /Users/josereyes/opt/anaconda3/envs/jose_env/lib/python3.8/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n",
      "Installing collected packages: pillow, kiwisolver, fonttools, cycler, matplotlib\n",
      "Successfully installed cycler-0.11.0 fonttools-4.28.5 kiwisolver-1.3.2 matplotlib-3.5.1 pillow-8.4.0\n"
     ]
    }
   ],
   "source": [
    "# install modules first\n",
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9de4b0ed-fc65-4915-9980-c48361487aac",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from datetime import date\n",
    "from datetime import datetime\n",
    "from timeit import default_timer as timer\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.metrics import precision_score, explained_variance_score\n",
    "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.ensemble import AdaBoostRegressor\n",
    "from sklearn.ensemble import BaggingRegressor\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn.ensemble import ExtraTreesRegressor\n",
    "from sklearn.ensemble import GradientBoostingRegressor\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.linear_model import RidgeCV\n",
    "from sklearn.linear_model import ARDRegression\n",
    "from sklearn.svm import LinearSVR\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import StackingRegressor\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.ensemble import StackingClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import LinearSVC\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "import pickle\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "99dbf969-be0e-4ed8-aef9-4615f4c1597b",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df = pd.read_csv('results_from_mongo.csv')\n",
    "results_df.drop(columns=['Unnamed: 0'],inplace=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "608fb66c-4ae2-45ef-b935-d3b6de9661a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# only keep 2021 for the api\n",
    "api_df = results_df[results_df['Season']==2021]\n",
    "api_df.reset_index(drop=True, inplace=True)\n",
    "api_df.to_csv(f'2021_races_drivers.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e99a9be-b977-4487-ac57-c3659d651d77",
   "metadata": {},
   "source": [
    "<a id='feature_eng'></a>\n",
    "### Feature Engineering\n",
    "\n",
    "At this stage, we will be creating the following features from exiting data:\n",
    "- Driver experience\n",
    "- Constructor experience\n",
    "- Driver Recent Wins\n",
    "- Driver Age\n",
    "- Driver Recent Form\n",
    "- Driver recent DNFs\n",
    "- Home Circuit advantage\n",
    "- Dummify the following categorical parameters: Season?, Race Name?, Number of Laps, Weather\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80b0565e-19e8-490e-b9a0-bb16a802c815",
   "metadata": {},
   "source": [
    "#### Driver experience\n",
    "Driver's experience in Formula 1, where a more experienced F1 driver typically places better than a rookie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "2e4219e9-e62c-4f55-812d-7955e038492f",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['DriverExperience'] = 0\n",
    "drivers = results_df['Driver'].unique()\n",
    "for driver in drivers:\n",
    "    df_driver = pd.DataFrame(results_df[results_df['Driver']==driver]).tail(60) # Arbitrary number, just look at the last x races\n",
    "    df_driver.loc[:,'DriverExperience'] = 1\n",
    "    \n",
    "    results_df.loc[results_df['Driver']==driver, \"DriverExperience\"] = df_driver['DriverExperience'].cumsum()\n",
    "    results_df['DriverExperience'].fillna(value=0,inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5de233d-d137-4a15-af2f-bfdb9181c451",
   "metadata": {},
   "source": [
    "#### Constructor Experience\n",
    "Constructor's experience in Formula 1, where a more experienced F1 constructor typically places better than a rookie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "ffdb661b-3051-4bb5-a0f5-3df6752c06bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['ConstructorExperience'] = 0\n",
    "constructors = results_df['Constructor'].unique()\n",
    "for constructor in constructors:\n",
    "    \n",
    "    df_constructor = pd.DataFrame(results_df[results_df['Constructor']==constructor]).tail(60) # Arbitrary number, just look at the last x races per driver\n",
    "    df_constructor.loc[:,'ConstructorExperience'] = 1\n",
    "    \n",
    "    results_df.loc[results_df['Constructor']==constructor, \"ConstructorExperience\"] = df_constructor['ConstructorExperience'].cumsum()\n",
    "    results_df['ConstructorExperience'].fillna(value=0,inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3402a97-0cdd-4934-965e-c9bf48d6e757",
   "metadata": {},
   "source": [
    "#### Driver Recent Wins\n",
    "A new feature is added to represent the dirver's most recent past wins. Excluding the result of the current race ensures that there is no possibility of data leakage that might affect the results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "74ad0dcd-8ae1-4a9b-b05b-33ec8cc3b398",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['DriverRecentWins'] = 0\n",
    "drivers = results_df['Driver'].unique()\n",
    "\n",
    "results_df.loc[results_df['Position']==1, \"DriverRecentWins\"] = 1\n",
    "for driver in drivers:\n",
    "    mask_first_place_drivers = (results_df['Driver']==driver) & (results_df['Position']==1)\n",
    "    df_driver = results_df[mask_first_place_drivers]\n",
    "    results_df.loc[results_df['Driver']==driver, \"DriverRecentWins\"] = results_df[results_df['Driver']==driver]['DriverRecentWins'].rolling(60).sum() # 60 races, about 3 years rolling\n",
    "    results_df.loc[mask_first_place_drivers, \"DriverRecentWins\"] = results_df[mask_first_place_drivers]['DriverRecentWins'] - 1  # but don't count this race's win\n",
    "    results_df['DriverRecentWins'].fillna(value=0,inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b9ebca5-0bee-4b28-b37a-bd0a4e0ec256",
   "metadata": {},
   "source": [
    "#### Driver Recent DNFs\n",
    "\n",
    "A new feature has also been added to represent a driver's recent DNFs (Did Not Finish), whatever/whoever's fault it is. We also have to take care and avoid data leakage into this new feature, by not counting the current race. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "14c237be-59bf-4545-97fc-912b15e2f8a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['DriverRecentDNFs'] = 0\n",
    "drivers = results_df['Driver'].unique()\n",
    "\n",
    "results_df.loc[(~results_df['Status'].str.contains('Finished|\\+')), \"DriverRecentDNFs\"] = 1\n",
    "for driver in drivers:\n",
    "    mask_not_finish_place_drivers = (results_df['Driver']==driver) & (~results_df['Status'].str.contains('Finished|\\+'))\n",
    "    df_driver = results_df[mask_not_finish_place_drivers]\n",
    "    results_df.loc[results_df['Driver']==driver, \"DriverRecentDNFs\"] = results_df[results_df['Driver']==driver]['DriverRecentDNFs'].rolling(60).sum() # 60 races, about 3 years rolling\n",
    "    results_df.loc[mask_not_finish_place_drivers, \"DriverRecentDNFs\"] = results_df[mask_not_finish_place_drivers]['DriverRecentDNFs'] - 1  # but don't count this race\n",
    "    results_df['DriverRecentDNFs'].fillna(value=0,inplace=True)\n",
    "\n",
    "# results_df[results_df['Driver']=='Daniel Ricciardo'].tail(60)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8709431d-8d6b-46a2-8212-33a86052f7f0",
   "metadata": {},
   "source": [
    "#### Fix issues with Recent form values\n",
    "\n",
    "In Formula 1, only the top 10 finishers score points, so even if a driver finished 11th, they will not score anything which will not help our calculation. So in this part, we give all finishers a score. The 1st place top points, and lower places get lower points and so on. We can then use this column as a variable (instead of F1's official points) to calclulate for the the Driver's recent form. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "8cd39925-c7e3-43aa-8345-859462c73d22",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add new RFPoints column - ALL finishers score points - max points First place and one less for each lesser place (using LogSpace)\n",
    "seasons = results_df['Season'].unique()\n",
    "results_df['RFPoints'] = 0\n",
    "for season in seasons:\n",
    "    rounds = results_df[results_df['Season']==season]['Round'].unique()\n",
    "    for round in rounds:\n",
    "        mask = (results_df['Season']==season) & (results_df['Round']==round)\n",
    "        finisher_mask = ((results_df['Status'].str.contains('Finished|\\+'))) # Count only if finished the race\n",
    "        finished_count = results_df.loc[(mask) & finisher_mask, \"RFPoints\"].count()\n",
    "        point_list = np.round(np.logspace(1,4,40, base=4),4) # use list of LogSpaced numbers\n",
    "        point_list[::-1].sort()\n",
    "        \n",
    "        results_df.loc[(mask) & finisher_mask, \"RFPoints\"] = point_list[:finished_count].tolist()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "484910ea-857a-4d78-b25f-aee2594920e9",
   "metadata": {},
   "source": [
    "#### Driver Recent Form\n",
    "Now that we've got our adjusted points system \"RFPoints\", we can now calculate for a more accurate Driver Recent Form. We also have to take care and avoid data leakage into this new feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "fd26a682-1d78-48be-920e-2e3c61226d6e",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['DriverRecentForm'] = 0\n",
    "# for all drivers, calculate the rolling X DriverRecentForm and add to a new column in \n",
    "# original data frame, this represents the 'recent form', then for NA's just impute to zero\n",
    "drivers = results_df['Driver'].unique()\n",
    "for driver in drivers:\n",
    "    df_driver = results_df[results_df['Driver']==driver]\n",
    "    results_df.loc[results_df['Driver']==driver, \"DriverRecentForm\"] = df_driver['RFPoints'].rolling(30).sum() - df_driver['RFPoints'] # calcluate recent form points but don't include this race's points\n",
    "    results_df['DriverRecentForm'].fillna(value=0,inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16e2608a-dc8a-485d-9447-f3391b51569e",
   "metadata": {},
   "source": [
    "#### Constructor Recent Form\n",
    "Now that we've got our adjusted points system \"RFPoints\", we can now also calculate for a more accurate Constructor Recent Form. We also have to take care and avoid data leakage into this new feature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "a8d2030d-b7f0-4529-a16b-e82f6a9a1ff0",
   "metadata": {},
   "outputs": [],
   "source": [
    "results_df['ConstructorRecentForm'] = 0\n",
    "# for all constructors, calculate the rolling X RFPoints and add to a new column in \n",
    "# original data frame, this represents the 'recent form', then for NA's just impute to zero\n",
    "constructors = results_df['Constructor'].unique()\n",
    "for constructor in constructors:\n",
    "    df_constructor = results_df[results_df['Constructor']==constructor]\n",
    "    results_df.loc[results_df['Constructor']==constructor, \"ConstructorRecentForm\"] = df_constructor['RFPoints'].rolling(30).sum() - df_constructor['RFPoints'] # calcluate recent form points but don't include this race's points\n",
    "    results_df['ConstructorRecentForm'].fillna(value=0,inplace=True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec4ac735-ff61-40ac-8b3c-6f52e8501788",
   "metadata": {},
   "source": [
    "#### Driver Age\n",
    "Surely a driver's age has some effect and may have some influence to the outcome of the race. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "22b66ffb-ff7b-406c-9e3f-0e34b03d6d59",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_age(born, race):\n",
    "    date_born = datetime.strptime(born,'%Y-%m-%d')\n",
    "    date_race = datetime.strptime(race,'%Y-%m-%d')\n",
    "    return date_race.year - date_born.year - ((date_race.month, date_race.day) < (date_born.month, date_born.day))\n",
    "\n",
    "results_df['Age'] = results_df.apply(lambda x: calculate_age(x['DOB'], x['Race Date']), axis=1) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49e7bab0-218d-4526-849a-dc6c512e61d2",
   "metadata": {},
   "source": [
    "#### Home Circuit\n",
    "Is there such a thing as Homecourt Advantage in Formula 1 racing? It doesn't look like it does, based on the preliminary EDA, however, I've got a feeling that it might have some. In the following cell, I have created a mapping between driver nationality vs race country, and this is used when we want to convey the Homecourt advantage concept in this model. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "4543dda5-bcb8-448c-af4f-fccdf0322316",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_race_in_home_country(driver_nationality, race_country):\n",
    "    nationality_country_map = {\n",
    "        'American': ['USA'],\n",
    "        'American-Italian': ['USA','Italy'],\n",
    "        'Argentine': ['Argentina'],\n",
    "        'Argentine-Italian': ['Argentina','Italy'],\n",
    "        'Australian': ['Australia'],\n",
    "        'Austrian': ['Austria'],\n",
    "        'Belgian': ['Belgium'],\n",
    "        'Brazilian': ['Brazil'],\n",
    "        'British': ['UK'],\n",
    "        'Canadian': ['Canada'],\n",
    "        'Chilean': ['Brazil'],\n",
    "        'Colombian': ['Brazil'],\n",
    "        'Czech': ['Austria','Germany'],\n",
    "        'Danish': ['Germany'],\n",
    "        'Dutch': ['Netherlands'],\n",
    "        'East German': ['Germany'],\n",
    "        'Finnish': ['Germany','Austria'],\n",
    "        'French': ['France'],\n",
    "        'German': ['Germany'],\n",
    "        'Hungarian': ['Hungary'],\n",
    "        'Indian': ['India'],\n",
    "        'Indonesian': ['Singapore','Malaysia'],\n",
    "        'Irish': ['UK'],\n",
    "        'Italian': ['Italy'],\n",
    "        'Japanese': ['Japan','Korea'],\n",
    "        'Liechtensteiner': ['Switzerland','Austria'],\n",
    "        'Malaysian': ['Malaysia','Singapore'],\n",
    "        'Mexican': ['Mexico'],\n",
    "        'Monegasque': ['Monaco'],\n",
    "        'New Zealander': ['Australia'],\n",
    "        'Polish': ['Germany'],\n",
    "        'Portuguese': ['Portugal'],\n",
    "        'Rhodesian': ['South Africa'],\n",
    "        'Russian': ['Russia'],\n",
    "        'South African': ['South Africa'],\n",
    "        'Spanish': ['Spain','Morocco'],\n",
    "        'Swedish': ['Sweden'],\n",
    "        'Swiss': ['Switzerland'],\n",
    "        'Thai': ['Malaysia'],\n",
    "        'Uruguayan': ['Argentina'],\n",
    "        'Venezuelan': ['Brazil']\n",
    "    }\n",
    "    \n",
    "    countries = ['None']\n",
    "    \n",
    "    try:\n",
    "      countries = nationality_country_map[driver_nationality]\n",
    "    except:\n",
    "      print(\"An exception occurred, This driver has no race held in his home country.\")\n",
    "    return race_country in countries\n",
    "\n",
    "results_df['IsHomeCountry'] = results_df.apply(lambda x: is_race_in_home_country(x['Nationality'], x['Country']), axis=1) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d72e084d-3562-4bd4-89ac-9a47f7a9269d",
   "metadata": {},
   "source": [
    "#### Handle all categorical variables\n",
    "Dummify applicable categorical variables and ensure that the variables for the model are all numeric.\n",
    "- Weather\n",
    "- Race name (circuit)\n",
    "- Driver nationality\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9aee8e0-c62f-4683-952c-6ee9884aa045",
   "metadata": {},
   "source": [
    "#### Dummify FTW\n",
    "Dummify the following parameters, and just drop irrelevant columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "463e9d69-15a3-4840-a77b-9b7fbfdbeebd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Season',\n",
       " 'Round',\n",
       " 'Race Date',\n",
       " 'Race Time',\n",
       " 'Position',\n",
       " 'Points',\n",
       " 'Grid',\n",
       " 'Laps',\n",
       " 'Status',\n",
       " 'Driver',\n",
       " 'DOB',\n",
       " 'Constructor',\n",
       " 'Constructor Nat',\n",
       " 'Circuit Name',\n",
       " 'Race Url',\n",
       " 'Lat',\n",
       " 'Long',\n",
       " 'Locality',\n",
       " 'Country',\n",
       " 'DriverExperience',\n",
       " 'ConstructorExperience',\n",
       " 'DriverRecentWins',\n",
       " 'DriverRecentDNFs',\n",
       " 'RFPoints',\n",
       " 'DriverRecentForm',\n",
       " 'ConstructorRecentForm',\n",
       " 'Age',\n",
       " 'IsHomeCountry',\n",
       " 'Weather_weather_cold',\n",
       " 'Weather_weather_dry',\n",
       " 'Weather_weather_hot',\n",
       " 'Weather_weather_warm',\n",
       " 'Weather_weather_wet',\n",
       " 'Nationality_Argentine',\n",
       " 'Nationality_Australian',\n",
       " 'Nationality_Austrian',\n",
       " 'Nationality_Belgian',\n",
       " 'Nationality_Brazilian',\n",
       " 'Nationality_British',\n",
       " 'Nationality_Canadian',\n",
       " 'Nationality_Dutch',\n",
       " 'Nationality_Finnish',\n",
       " 'Nationality_French',\n",
       " 'Nationality_German',\n",
       " 'Nationality_Italian',\n",
       " 'Nationality_Japanese',\n",
       " 'Nationality_Mexican',\n",
       " 'Nationality_New Zealander',\n",
       " 'Nationality_Spanish',\n",
       " 'Nationality_Swedish',\n",
       " 'Nationality_Swiss',\n",
       " 'Race Name_Abu Dhabi Grand Prix',\n",
       " 'Race Name_Argentine Grand Prix',\n",
       " 'Race Name_Australian Grand Prix',\n",
       " 'Race Name_Austrian Grand Prix',\n",
       " 'Race Name_Bahrain Grand Prix',\n",
       " 'Race Name_Belgian Grand Prix',\n",
       " 'Race Name_Brazilian Grand Prix',\n",
       " 'Race Name_British Grand Prix',\n",
       " 'Race Name_Canadian Grand Prix',\n",
       " 'Race Name_Chinese Grand Prix',\n",
       " 'Race Name_Detroit Grand Prix',\n",
       " 'Race Name_Dutch Grand Prix',\n",
       " 'Race Name_European Grand Prix',\n",
       " 'Race Name_French Grand Prix',\n",
       " 'Race Name_German Grand Prix',\n",
       " 'Race Name_Hungarian Grand Prix',\n",
       " 'Race Name_Indianapolis 500',\n",
       " 'Race Name_Italian Grand Prix',\n",
       " 'Race Name_Japanese Grand Prix',\n",
       " 'Race Name_Malaysian Grand Prix',\n",
       " 'Race Name_Mexican Grand Prix',\n",
       " 'Race Name_Monaco Grand Prix',\n",
       " 'Race Name_Portuguese Grand Prix',\n",
       " 'Race Name_Russian Grand Prix',\n",
       " 'Race Name_San Marino Grand Prix',\n",
       " 'Race Name_Singapore Grand Prix',\n",
       " 'Race Name_South African Grand Prix',\n",
       " 'Race Name_Spanish Grand Prix',\n",
       " 'Race Name_Swedish Grand Prix',\n",
       " 'Race Name_Turkish Grand Prix',\n",
       " 'Race Name_United States Grand Prix',\n",
       " 'Race Name_United States Grand Prix West']"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Weather\n",
    "results_df = pd.get_dummies(results_df, columns = ['Weather', 'Nationality', 'Race Name'],drop_first=True)\n",
    "\n",
    "for col in results_df.columns:\n",
    "    if 'Nationality' in col and results_df[col].sum() < 300:\n",
    "        results_df.drop(col, axis = 1, inplace = True)\n",
    "        \n",
    "    elif 'Race Name' in col and results_df[col].sum() < 130:\n",
    "        results_df.drop(col, axis = 1, inplace = True)\n",
    "        \n",
    "    else:\n",
    "        pass\n",
    "results_df.columns.tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "8f57b7a3-5177-44e6-87b2-a87006c5f41c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25380, 68)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### Drop Columns which are not needed/required for modelling\n",
    "results_df.drop(['Race Date', 'Race Time', 'Status', 'DOB', 'Constructor', 'Constructor Nat', 'Circuit Name',\n",
    "                 'Race Url', 'Lat', 'Long', 'Locality', 'Country','Laps','Points',\n",
    "                 'RFPoints'], axis=1, inplace=True)\n",
    "results_df.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "48ef1f71-7c0e-4514-84f6-15a639c75884",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Season', 'Round', 'Position', 'Grid', 'Driver', 'DriverExperience',\n",
       "       'ConstructorExperience', 'DriverRecentWins', 'DriverRecentDNFs',\n",
       "       'DriverRecentForm', 'ConstructorRecentForm', 'Age', 'IsHomeCountry',\n",
       "       'Weather_weather_cold', 'Weather_weather_dry', 'Weather_weather_hot',\n",
       "       'Weather_weather_warm', 'Weather_weather_wet', 'Nationality_Argentine',\n",
       "       'Nationality_Australian', 'Nationality_Austrian', 'Nationality_Belgian',\n",
       "       'Nationality_Brazilian', 'Nationality_British', 'Nationality_Canadian',\n",
       "       'Nationality_Dutch', 'Nationality_Finnish', 'Nationality_French',\n",
       "       'Nationality_German', 'Nationality_Italian', 'Nationality_Japanese',\n",
       "       'Nationality_Mexican', 'Nationality_New Zealander',\n",
       "       'Nationality_Spanish', 'Nationality_Swedish', 'Nationality_Swiss',\n",
       "       'Race Name_Abu Dhabi Grand Prix', 'Race Name_Argentine Grand Prix',\n",
       "       'Race Name_Australian Grand Prix', 'Race Name_Austrian Grand Prix',\n",
       "       'Race Name_Bahrain Grand Prix', 'Race Name_Belgian Grand Prix',\n",
       "       'Race Name_Brazilian Grand Prix', 'Race Name_British Grand Prix',\n",
       "       'Race Name_Canadian Grand Prix', 'Race Name_Chinese Grand Prix',\n",
       "       'Race Name_Detroit Grand Prix', 'Race Name_Dutch Grand Prix',\n",
       "       'Race Name_European Grand Prix', 'Race Name_French Grand Prix',\n",
       "       'Race Name_German Grand Prix', 'Race Name_Hungarian Grand Prix',\n",
       "       'Race Name_Indianapolis 500', 'Race Name_Italian Grand Prix',\n",
       "       'Race Name_Japanese Grand Prix', 'Race Name_Malaysian Grand Prix',\n",
       "       'Race Name_Mexican Grand Prix', 'Race Name_Monaco Grand Prix',\n",
       "       'Race Name_Portuguese Grand Prix', 'Race Name_Russian Grand Prix',\n",
       "       'Race Name_San Marino Grand Prix', 'Race Name_Singapore Grand Prix',\n",
       "       'Race Name_South African Grand Prix', 'Race Name_Spanish Grand Prix',\n",
       "       'Race Name_Swedish Grand Prix', 'Race Name_Turkish Grand Prix',\n",
       "       'Race Name_United States Grand Prix',\n",
       "       'Race Name_United States Grand Prix West'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df['Season'] = pd.to_numeric(results_df['Season'])\n",
    "results_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "61d735f4-3aef-4008-b3b1-db4f9dcaccd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_raw ={'model':[], 'params': [], 'score': [], 'train_time': [], 'test_time': []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "dcc9df47-c105-43fe-8997-94557ea92644",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "# Prepare train set\n",
    "np.set_printoptions(precision=4)\n",
    "model_df = results_df.copy()\n",
    "model_df['Position'] = model_df['Position'].map(lambda x: 1 if x == 1 else 0)\n",
    "\n",
    "train = model_df[(model_df['Season'] >= 1950) & (model_df['Season'] < 2021)]\n",
    "X_train = train.drop(['Position','Driver'], axis = 1)\n",
    "y_train = train['Position']\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "X_train = pd.DataFrame(scaler.fit_transform(X_train, y_train), columns = X_train.columns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "d4e8bea0-c0f7-4b66-a7cd-f36a4dcb5596",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Season', 'Round', 'Position', 'Grid', 'Driver', 'DriverExperience',\n",
       "       'ConstructorExperience', 'DriverRecentWins', 'DriverRecentDNFs',\n",
       "       'DriverRecentForm', 'ConstructorRecentForm', 'Age', 'IsHomeCountry',\n",
       "       'Weather_weather_cold', 'Weather_weather_dry', 'Weather_weather_hot',\n",
       "       'Weather_weather_warm', 'Weather_weather_wet', 'Nationality_Argentine',\n",
       "       'Nationality_Australian', 'Nationality_Austrian', 'Nationality_Belgian',\n",
       "       'Nationality_Brazilian', 'Nationality_British', 'Nationality_Canadian',\n",
       "       'Nationality_Dutch', 'Nationality_Finnish', 'Nationality_French',\n",
       "       'Nationality_German', 'Nationality_Italian', 'Nationality_Japanese',\n",
       "       'Nationality_Mexican', 'Nationality_New Zealander',\n",
       "       'Nationality_Spanish', 'Nationality_Swedish', 'Nationality_Swiss',\n",
       "       'Race Name_Abu Dhabi Grand Prix', 'Race Name_Argentine Grand Prix',\n",
       "       'Race Name_Australian Grand Prix', 'Race Name_Austrian Grand Prix',\n",
       "       'Race Name_Bahrain Grand Prix', 'Race Name_Belgian Grand Prix',\n",
       "       'Race Name_Brazilian Grand Prix', 'Race Name_British Grand Prix',\n",
       "       'Race Name_Canadian Grand Prix', 'Race Name_Chinese Grand Prix',\n",
       "       'Race Name_Detroit Grand Prix', 'Race Name_Dutch Grand Prix',\n",
       "       'Race Name_European Grand Prix', 'Race Name_French Grand Prix',\n",
       "       'Race Name_German Grand Prix', 'Race Name_Hungarian Grand Prix',\n",
       "       'Race Name_Indianapolis 500', 'Race Name_Italian Grand Prix',\n",
       "       'Race Name_Japanese Grand Prix', 'Race Name_Malaysian Grand Prix',\n",
       "       'Race Name_Mexican Grand Prix', 'Race Name_Monaco Grand Prix',\n",
       "       'Race Name_Portuguese Grand Prix', 'Race Name_Russian Grand Prix',\n",
       "       'Race Name_San Marino Grand Prix', 'Race Name_Singapore Grand Prix',\n",
       "       'Race Name_South African Grand Prix', 'Race Name_Spanish Grand Prix',\n",
       "       'Race Name_Swedish Grand Prix', 'Race Name_Turkish Grand Prix',\n",
       "       'Race Name_United States Grand Prix',\n",
       "       'Race Name_United States Grand Prix West'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f5936dd-27d5-45a4-baa4-2ab0fd28b907",
   "metadata": {},
   "source": [
    "\n",
    "#### Regression Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f1a2af21-df0e-489c-a0a7-3e276766b335",
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_test_score(model, print_output=False):\n",
    "    # --- Test ---\n",
    "    score = 0\n",
    "    races = model_df[(model_df['Season'] == 2021)]['Round'].unique()\n",
    "    for race in races:\n",
    "        test = model_df[(model_df['Season'] == 2021) & (model_df['Round'] == race)]\n",
    "        X_test = test.drop(['Position','Driver'], axis = 1)\n",
    "        y_test = test['Position']\n",
    "        X_test = pd.DataFrame(scaler.transform(X_test), columns = X_test.columns)\n",
    "        X_test.to_csv(f'{2021}_{race}.csv')\n",
    "\n",
    "        # make predictions\n",
    "        prediction_df = pd.DataFrame(model.predict(X_test), columns = ['prediction'])\n",
    "        merged_df = pd.concat([prediction_df, test[['Driver','Position']].reset_index(drop=True)], axis=1)\n",
    "        merged_df.rename(columns = {'Position': 'actual_pos'}, inplace = True)\n",
    "        \n",
    "        # shuffle data to remove original order that will influence selection\n",
    "        # of race winner when there are drivers with identical win probablilities\n",
    "        merged_df = merged_df.sample(frac=1).reset_index(drop=True) \n",
    "        merged_df.sort_values(by='prediction', ascending=False, inplace=True)\n",
    "        merged_df['predicted_pos'] = merged_df['prediction'].map(lambda x: 0)\n",
    "        merged_df.iloc[0, merged_df.columns.get_loc('predicted_pos')] = 1\n",
    "        merged_df.reset_index(drop=True, inplace=True)\n",
    "        if (print_output == True):\n",
    "            print(merged_df)\n",
    "\n",
    "        # --- Score --- \n",
    "        score += precision_score(merged_df['actual_pos'], merged_df['predicted_pos'], zero_division=0)\n",
    "        \n",
    "    return score / len(races)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6867c77a-20b9-4331-9cea-9ccd5b5ef4fa",
   "metadata": {},
   "source": [
    "#### Dumb Classifier\n",
    "\n",
    "I have created a a dumb classifier and all it does is create a list of numbers between 0.001 and 0.99 which represents the order of finishing, and shuffle for good measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2263c436-6688-41cf-aa5b-ea360af41b77",
   "metadata": {},
   "outputs": [],
   "source": [
    "class F1OracleDumbClassifier(BaseEstimator):\n",
    "    def fit(self, X, y=None):\n",
    "        pass\n",
    "    def predict(self, X):\n",
    "        # numbers between 0.001 to 0.99 and shuffle - jose's awesome dumb classifier!\n",
    "        numbers = np.round(np.logspace(np.log10(0.001),np.log10(0.999),len(X)),4)\n",
    "        np.random.shuffle(numbers)\n",
    "        return numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8cf8d841-1a30-42ca-a0a4-650ce3c1ae3c",
   "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</th>\n",
       "      <th>params</th>\n",
       "      <th>score</th>\n",
       "      <th>train_time</th>\n",
       "      <th>test_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Jose's Dumb Classifier</td>\n",
       "      <td>none</td>\n",
       "      <td>4.762</td>\n",
       "      <td>0.000001</td>\n",
       "      <td>0.12515</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    model params  score  train_time  test_time\n",
       "0  Jose's Dumb Classifier   none  4.762    0.000001    0.12515"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def joses_dumb_classifier(X_train, y_train):\n",
    "    start = timer()\n",
    "    model = F1OracleDumbClassifier()\n",
    "    model.fit(X_train, y_train)\n",
    "    end = timer()\n",
    "    scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "    start = timer()\n",
    "    model_score = regression_test_score(model)\n",
    "    end = timer()\n",
    "\n",
    "    scoring_raw['model'].append(\"Jose's Dumb Classifier\")\n",
    "    scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "    scoring_raw['params'].append('none')\n",
    "    scoring_raw['test_time'].append(end - start)\n",
    "        \n",
    "joses_dumb_classifier(X_train, y_train)\n",
    "running_score = pd.DataFrame(scoring_raw)\n",
    "running_score\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e0a879f-fb26-48e2-bdff-239d9d0db40c",
   "metadata": {},
   "source": [
    "<a id='feature_importance'></a>\n",
    "#### Feature Importance using Linear Regression Coefficients\n",
    "\n",
    "Using Linear Regression, we can identify the most relevant features, so that we may be able to remove the features that don't add any value, but bloat. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "id": "e5edb8b4-50ce-4037-b03f-700fa9d37477",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def feature_importance_using_linear_regression(X_train, y_train):\n",
    "    model = LinearRegression()\n",
    "    model.fit(X_train, y_train)\n",
    "\n",
    "    # Assess the importance of features using Linear Regression coefficients\n",
    "    importance = model.coef_\n",
    "    importance_df = pd.DataFrame(importance, columns = ['importance'])\n",
    "    features_df = pd.DataFrame(results_df.columns.tolist(), columns = ['feature_name'])\n",
    "    features_df.drop(features_df[(features_df['feature_name'] == 'Driver') | (features_df['feature_name'] == 'Position')].index, inplace=True)\n",
    "    merged_features_df = pd.concat([importance_df, features_df.reset_index(drop=True)], axis=1)\n",
    "    merged_features_df.sort_values(by='importance', ascending=True, inplace=True)\n",
    "    merged_features_df.set_index('feature_name', inplace=True)\n",
    "    selected_features_df = merged_features_df[(merged_features_df['importance'] > 0)][['importance']]\n",
    "\n",
    "    # plot feature importance \n",
    "    axis = selected_features_df.plot(kind='barh', title=\"F1 Prediction Feature Importance\", figsize=(16, 10), color='#00CC99')\n",
    "    y_label = axis.yaxis.get_label()\n",
    "    y_label.set_visible(False)\n",
    "\n",
    "feature_importance_using_linear_regression(X_train, y_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f41cd68-7070-4d27-b333-a0f3e26a4317",
   "metadata": {},
   "source": [
    "#### Feature importance using Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 533,
   "id": "5a375479-21af-487f-b522-d105c68ed637",
   "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>imp_mask</th>\n",
       "      <th>importance</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>feature_name</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Grid</th>\n",
       "      <td>True</td>\n",
       "      <td>0.150197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DriverRecentForm</th>\n",
       "      <td>True</td>\n",
       "      <td>0.119112</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ConstructorRecentForm</th>\n",
       "      <td>True</td>\n",
       "      <td>0.113140</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DriverRecentWins</th>\n",
       "      <td>True</td>\n",
       "      <td>0.073343</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Season</th>\n",
       "      <td>True</td>\n",
       "      <td>0.066364</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Round</th>\n",
       "      <td>True</td>\n",
       "      <td>0.063992</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Age</th>\n",
       "      <td>True</td>\n",
       "      <td>0.060626</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DriverRecentDNFs</th>\n",
       "      <td>True</td>\n",
       "      <td>0.047086</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DriverExperience</th>\n",
       "      <td>True</td>\n",
       "      <td>0.045102</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Weather_weather_warm</th>\n",
       "      <td>True</td>\n",
       "      <td>0.016472</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ConstructorExperience</th>\n",
       "      <td>False</td>\n",
       "      <td>0.013140</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Weather_weather_dry</th>\n",
       "      <td>False</td>\n",
       "      <td>0.010116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_British</th>\n",
       "      <td>False</td>\n",
       "      <td>0.010064</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Weather_weather_hot</th>\n",
       "      <td>False</td>\n",
       "      <td>0.008448</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Italian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.008315</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Weather_weather_wet</th>\n",
       "      <td>False</td>\n",
       "      <td>0.008052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Belgian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007769</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>IsHomeCountry</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_British Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007701</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Monaco Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007615</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_German Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007439</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_French Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.007222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_German</th>\n",
       "      <td>False</td>\n",
       "      <td>0.006735</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_United States Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.006140</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Brazilian</th>\n",
       "      <td>False</td>\n",
       "      <td>0.006081</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Spanish Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Canadian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005885</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Brazilian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005844</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Austrian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005482</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Hungarian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005455</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_French</th>\n",
       "      <td>False</td>\n",
       "      <td>0.005127</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Australian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.004712</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Finnish</th>\n",
       "      <td>False</td>\n",
       "      <td>0.004693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Australian</th>\n",
       "      <td>False</td>\n",
       "      <td>0.004413</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Japanese Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.004334</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Dutch Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003995</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_European Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003828</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Weather_weather_cold</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Italian</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003739</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_San Marino Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003566</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_South African Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003518</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Austrian</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003452</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Argentine Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003199</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Argentine</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003165</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Mexican Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003160</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Malaysian Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003118</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Portuguese Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.003011</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Spanish</th>\n",
       "      <td>False</td>\n",
       "      <td>0.002691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Race Name_Chinese Grand Prix</th>\n",
       "      <td>False</td>\n",
       "      <td>0.002614</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Nationality_Canadian</th>\n",
       "      <td>False</td>\n",
       "      <td>0.002482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                    imp_mask  importance\n",
       "feature_name                                            \n",
       "Grid                                    True    0.150197\n",
       "DriverRecentForm                        True    0.119112\n",
       "ConstructorRecentForm                   True    0.113140\n",
       "DriverRecentWins                        True    0.073343\n",
       "Season                                  True    0.066364\n",
       "Round                                   True    0.063992\n",
       "Age                                     True    0.060626\n",
       "DriverRecentDNFs                        True    0.047086\n",
       "DriverExperience                        True    0.045102\n",
       "Weather_weather_warm                    True    0.016472\n",
       "ConstructorExperience                  False    0.013140\n",
       "Weather_weather_dry                    False    0.010116\n",
       "Nationality_British                    False    0.010064\n",
       "Weather_weather_hot                    False    0.008448\n",
       "Race Name_Italian Grand Prix           False    0.008315\n",
       "Weather_weather_wet                    False    0.008052\n",
       "Race Name_Belgian Grand Prix           False    0.007769\n",
       "IsHomeCountry                          False    0.007731\n",
       "Race Name_British Grand Prix           False    0.007701\n",
       "Race Name_Monaco Grand Prix            False    0.007615\n",
       "Race Name_German Grand Prix            False    0.007439\n",
       "Race Name_French Grand Prix            False    0.007222\n",
       "Nationality_German                     False    0.006735\n",
       "Race Name_United States Grand Prix     False    0.006140\n",
       "Nationality_Brazilian                  False    0.006081\n",
       "Race Name_Spanish Grand Prix           False    0.005951\n",
       "Race Name_Canadian Grand Prix          False    0.005885\n",
       "Race Name_Brazilian Grand Prix         False    0.005844\n",
       "Race Name_Austrian Grand Prix          False    0.005482\n",
       "Race Name_Hungarian Grand Prix         False    0.005455\n",
       "Nationality_French                     False    0.005127\n",
       "Race Name_Australian Grand Prix        False    0.004712\n",
       "Nationality_Finnish                    False    0.004693\n",
       "Nationality_Australian                 False    0.004413\n",
       "Race Name_Japanese Grand Prix          False    0.004334\n",
       "Race Name_Dutch Grand Prix             False    0.003995\n",
       "Race Name_European Grand Prix          False    0.003828\n",
       "Weather_weather_cold                   False    0.003777\n",
       "Nationality_Italian                    False    0.003739\n",
       "Race Name_San Marino Grand Prix        False    0.003566\n",
       "Race Name_South African Grand Prix     False    0.003518\n",
       "Nationality_Austrian                   False    0.003452\n",
       "Race Name_Argentine Grand Prix         False    0.003199\n",
       "Nationality_Argentine                  False    0.003165\n",
       "Race Name_Mexican Grand Prix           False    0.003160\n",
       "Race Name_Malaysian Grand Prix         False    0.003118\n",
       "Race Name_Portuguese Grand Prix        False    0.003011\n",
       "Nationality_Spanish                    False    0.002691\n",
       "Race Name_Chinese Grand Prix           False    0.002614\n",
       "Nationality_Canadian                   False    0.002482"
      ]
     },
     "execution_count": 533,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x1440 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def feature_importance_using_random_forest(X_train, y_train):\n",
    "    sel = SelectFromModel(RandomForestClassifier(n_estimators = 100))\n",
    "    sel.fit(X_train, y_train)\n",
    "    features_to_keep = sel.get_support()\n",
    "    feature_importance_df = pd.DataFrame(\n",
    "        {'feature_name': X_train.columns.tolist(),\n",
    "         'imp_mask': sel.get_support(),\n",
    "         'importance': sel.estimator_.feature_importances_\n",
    "        })\n",
    "    return feature_importance_df, features_to_keep\n",
    "    \n",
    "feature_importance_df, features_to_keep = feature_importance_using_random_forest(X_train, y_train)\n",
    "# feature_importance_df = feature_importance_df[feature_importance_df['imp_mask']==True]\n",
    "feature_importance_df.sort_values(by='importance', inplace=True)\n",
    "feature_importance_df.reset_index(drop=True, inplace=True)\n",
    "feature_importance_df.set_index('feature_name', inplace=True)\n",
    "\n",
    "# plot feature importance \n",
    "axis = feature_importance_df.plot(kind='barh', title=\"F1 Prediction Feature Importance\", figsize=(16, 20), color='#00CC99')\n",
    "y_label = axis.yaxis.get_label()\n",
    "y_label.set_visible(False)\n",
    "feature_importance_df = feature_importance_df.nlargest(50, 'importance')\n",
    "feature_importance_df\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7704ce0a-49f0-4bf4-8884-f7b0bea18cdb",
   "metadata": {},
   "source": [
    "<a id='feature_selection'></a>\n",
    "#### Feature Selection\n",
    "Based on the feature importance discovered in the previous section, the identified insignificant features can be safely ommitted as it contributes to model bloat. I've decided to use the features identified by **Random Forest**, since I did not trust the ones from **Linear Regression**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 535,
   "id": "66ce8dbd-1e63-4f07-9173-b29444a1c48d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Grid', 'DriverRecentForm', 'ConstructorRecentForm', 'DriverRecentWins',\n",
       "       'Season', 'Round', 'Age', 'DriverRecentDNFs', 'DriverExperience',\n",
       "       'Weather_weather_warm', 'ConstructorExperience', 'Weather_weather_dry',\n",
       "       'Nationality_British', 'Weather_weather_hot',\n",
       "       'Race Name_Italian Grand Prix', 'Weather_weather_wet',\n",
       "       'Race Name_Belgian Grand Prix', 'IsHomeCountry',\n",
       "       'Race Name_British Grand Prix', 'Race Name_Monaco Grand Prix',\n",
       "       'Race Name_German Grand Prix', 'Race Name_French Grand Prix',\n",
       "       'Nationality_German', 'Race Name_United States Grand Prix',\n",
       "       'Nationality_Brazilian', 'Race Name_Spanish Grand Prix',\n",
       "       'Race Name_Canadian Grand Prix', 'Race Name_Brazilian Grand Prix',\n",
       "       'Race Name_Austrian Grand Prix', 'Race Name_Hungarian Grand Prix',\n",
       "       'Nationality_French', 'Race Name_Australian Grand Prix',\n",
       "       'Nationality_Finnish', 'Nationality_Australian',\n",
       "       'Race Name_Japanese Grand Prix', 'Race Name_Dutch Grand Prix',\n",
       "       'Race Name_European Grand Prix', 'Weather_weather_cold',\n",
       "       'Nationality_Italian', 'Race Name_San Marino Grand Prix',\n",
       "       'Race Name_South African Grand Prix', 'Nationality_Austrian',\n",
       "       'Race Name_Argentine Grand Prix', 'Nationality_Argentine',\n",
       "       'Race Name_Mexican Grand Prix', 'Race Name_Malaysian Grand Prix',\n",
       "       'Race Name_Portuguese Grand Prix', 'Nationality_Spanish',\n",
       "       'Race Name_Chinese Grand Prix', 'Nationality_Canadian', 'Position',\n",
       "       'Driver'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 535,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def keep_significant_features():\n",
    "    # keep significant features (Position and Driver will be dropped later, we still need them)\n",
    "    return results_df[feature_importance_df.index.tolist() + ['Position','Driver']]\n",
    "results_df = keep_significant_features()\n",
    "results_df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "aaa66c1c-9786-4e7c-a8fc-762f1ab30647",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25380, 68)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 537,
   "id": "dc208cc8-cd2f-4a41-9610-c3eb89d6ac68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24800, 50)"
      ]
     },
     "execution_count": 537,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "# Prepare train set\n",
    "np.set_printoptions(precision=4)\n",
    "model_df = results_df.copy()\n",
    "model_df['Position'] = model_df['Position'].map(lambda x: 1 if x == 1 else 0)\n",
    "\n",
    "train = model_df[(model_df['Season'] >= 1950) & (model_df['Season'] < 2021)]\n",
    "X_train = train.drop(['Position','Driver'], axis = 1)\n",
    "y_train = train['Position']\n",
    "\n",
    "scaler = MinMaxScaler()\n",
    "X_train = pd.DataFrame(scaler.fit_transform(X_train, y_train), columns = X_train.columns)\n",
    "X_train.shape\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "921fcb41-6e62-43f5-a979-c1b08d757ea9",
   "metadata": {},
   "source": [
    "<a id='regression_approaches'></a>\n",
    "### Regression Approaches\n",
    "\n",
    "The problem of predicting the winner of a race can be considered a regression problem. We do this by submitting the independent variables (20 drivers) to the chosen machine learning algorithm, and allow the algorithm to make a winner prediction. In fact, the estimator does not only pick a winner among the 20 drivers. It responds with a \"prediction\" column, where it is sorted descending order, and can be used as the predicted finishing order of the race. The driver that ends up at the top of this list is the winner of this race. \n",
    "\n",
    "The following Regression techniques are applied to help solve our problem:\n",
    "- Linear Regression\n",
    "- Ada Boost Regressor\n",
    "- Bagging Regressor\n",
    "- Extra Trees Regressor\n",
    "- Gradient Boosting Regressor\n",
    "- Random Forest Regressor\n",
    "- Stacking Regressor\n",
    "- Neural Network (MLP Regressor)\n",
    "\n",
    "<img src=\"presentation/reveal.js/images/f1-regression-approach.png\" width=\"600\" height=\"400\" />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d51fafc3-277b-4be0-81a4-94dd17ccfd32",
   "metadata": {},
   "source": [
    "#### Linear Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "77af755b-eb5f-4501-9943-6b279b37ecce",
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_regression(X_train, y_train):\n",
    "    params={'fit_intercept': ['True', 'False']}\n",
    "\n",
    "    for fit_intercept in params['fit_intercept']:\n",
    "        start = timer()\n",
    "        model_params = (fit_intercept)\n",
    "        model = LinearRegression(fit_intercept = fit_intercept)\n",
    "        model.fit(X_train, y_train)\n",
    "        end = timer()\n",
    "        scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "        start = timer()\n",
    "        model_score = regression_test_score(model)\n",
    "        end = timer()\n",
    "\n",
    "        scoring_raw['model'].append('Linear Regression')\n",
    "        scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "        scoring_raw['params'].append(model_params)\n",
    "        scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "912137be-63a6-4a9c-b597-eae86bca77d0",
   "metadata": {},
   "source": [
    "#### AdaBoost Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "d79b1772-5bf4-4927-b706-4a49e6657538",
   "metadata": {},
   "outputs": [],
   "source": [
    "def adaboost_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'learning_rate': [0.001,0.01,0.1,1],\n",
    "            'loss': ['linear','square','exponential']}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for learning_rate in params['learning_rate']:\n",
    "            for loss in params['loss']:\n",
    "                start = timer()\n",
    "                model_params = (n_estimators, learning_rate, loss)\n",
    "                model = AdaBoostRegressor(random_state=0, n_estimators=n_estimators, learning_rate=learning_rate, loss=loss)\n",
    "                model.fit(X_train, y_train)\n",
    "                end = timer()\n",
    "                scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                start = timer()\n",
    "                model_score = regression_test_score(model)\n",
    "                end = timer()\n",
    "\n",
    "                scoring_raw['model'].append('AdaBoost Regressor')\n",
    "                scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                scoring_raw['params'].append(model_params)\n",
    "                scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d339a9b9-858b-4511-b50b-30968a59b78a",
   "metadata": {},
   "source": [
    "#### Bagging Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 526,
   "id": "097c8f28-3b38-4269-950a-4ed9378792fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bagging_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_samples': [10,20,30],\n",
    "            'max_features': [20,40,50],\n",
    "            'bootstrap': [True,False],\n",
    "            'bootstrap_features': [True,False]}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for max_samples in params['max_samples']:\n",
    "            for max_features in params['max_features']:\n",
    "                for bootstrap in params['bootstrap']:\n",
    "                    for bootstrap_features in params['bootstrap_features']:\n",
    "                        start = timer()\n",
    "                        model_params = (n_estimators, max_samples, max_features, bootstrap, bootstrap_features)\n",
    "                        model = BaggingRegressor(random_state=0, base_estimator=DecisionTreeRegressor(),\n",
    "                             n_estimators=n_estimators, max_samples=max_samples, max_features=max_features, bootstrap=bootstrap, bootstrap_features=bootstrap_features)\n",
    "                        model.fit(X_train, y_train)\n",
    "                        end = timer()\n",
    "                        scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                        start = timer()\n",
    "                        model_score = regression_test_score(model)\n",
    "                        end = timer()\n",
    "\n",
    "                        scoring_raw['model'].append('Bagging Regressor (DT)')\n",
    "                        scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                        scoring_raw['params'].append(model_params)\n",
    "                        scoring_raw['test_time'].append(end - start)\n",
    "        \n",
    "bagging_regressor(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 496,
   "id": "bf89d1cc-0e25-4f77-b458-bf3e9882c129",
   "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</th>\n",
       "      <th>params</th>\n",
       "      <th>score</th>\n",
       "      <th>train_time</th>\n",
       "      <th>test_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 20, True, True)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.233318</td>\n",
       "      <td>0.353067</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 20, True, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.213632</td>\n",
       "      <td>0.354575</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 20, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.212461</td>\n",
       "      <td>0.357825</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 20, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.211680</td>\n",
       "      <td>0.353857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 50, True, True)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>0.480269</td>\n",
       "      <td>0.346802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 50, True, False)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.468580</td>\n",
       "      <td>0.346213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 50, False, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.467698</td>\n",
       "      <td>0.347006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 50, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.462829</td>\n",
       "      <td>0.349061</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 60, True, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.577932</td>\n",
       "      <td>0.353337</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 60, True, False)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.586996</td>\n",
       "      <td>0.347714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 60, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.591305</td>\n",
       "      <td>0.348392</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 10, 60, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.597226</td>\n",
       "      <td>0.360252</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 20, True, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.211228</td>\n",
       "      <td>0.339423</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 20, True, False)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.211595</td>\n",
       "      <td>0.361912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 20, False, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.226894</td>\n",
       "      <td>0.341176</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 20, False, False)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.213197</td>\n",
       "      <td>0.350047</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 50, True, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.458122</td>\n",
       "      <td>0.346450</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 50, True, False)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>0.469801</td>\n",
       "      <td>0.348179</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 50, False, True)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.475078</td>\n",
       "      <td>0.346943</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 50, False, False)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>0.463000</td>\n",
       "      <td>0.366208</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 60, True, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.607960</td>\n",
       "      <td>0.361641</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 60, True, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.586441</td>\n",
       "      <td>0.346637</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 60, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.584668</td>\n",
       "      <td>0.357027</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 20, 60, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.588140</td>\n",
       "      <td>0.347868</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 20, True, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.214778</td>\n",
       "      <td>0.341378</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 20, True, False)</td>\n",
       "      <td>52.381</td>\n",
       "      <td>0.211576</td>\n",
       "      <td>0.353158</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 20, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.218099</td>\n",
       "      <td>0.347623</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 20, False, False)</td>\n",
       "      <td>52.381</td>\n",
       "      <td>0.218288</td>\n",
       "      <td>0.350863</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 50, True, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.458911</td>\n",
       "      <td>0.344267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 50, True, False)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.474571</td>\n",
       "      <td>0.355489</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 50, False, True)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.472724</td>\n",
       "      <td>0.344054</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 50, False, False)</td>\n",
       "      <td>42.857</td>\n",
       "      <td>0.485122</td>\n",
       "      <td>0.345893</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 60, True, True)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.595225</td>\n",
       "      <td>0.342590</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 60, True, False)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.605169</td>\n",
       "      <td>0.344667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 60, False, True)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.598013</td>\n",
       "      <td>0.344473</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(100, 30, 60, False, False)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.610230</td>\n",
       "      <td>0.347696</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 20, True, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.413500</td>\n",
       "      <td>0.484519</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 20, True, False)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.426104</td>\n",
       "      <td>0.472942</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 20, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.421968</td>\n",
       "      <td>0.472197</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 20, False, False)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>0.414768</td>\n",
       "      <td>0.470777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 50, True, True)</td>\n",
       "      <td>66.667</td>\n",
       "      <td>0.924459</td>\n",
       "      <td>0.477019</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 50, True, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.934540</td>\n",
       "      <td>0.475284</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 50, False, True)</td>\n",
       "      <td>61.905</td>\n",
       "      <td>0.918467</td>\n",
       "      <td>0.473058</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 50, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.915788</td>\n",
       "      <td>0.477709</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 60, True, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>1.191411</td>\n",
       "      <td>0.487758</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 60, True, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>1.179926</td>\n",
       "      <td>0.486977</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 60, False, True)</td>\n",
       "      <td>33.333</td>\n",
       "      <td>1.174052</td>\n",
       "      <td>0.475252</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 10, 60, False, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>1.199397</td>\n",
       "      <td>0.491126</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 20, 20, True, True)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.416047</td>\n",
       "      <td>0.476726</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>Bagging Regressor (DT)</td>\n",
       "      <td>(200, 20, 20, True, False)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.424252</td>\n",
       "      <td>0.469221</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     model                       params   score  train_time  \\\n",
       "0   Bagging Regressor (DT)    (100, 10, 20, True, True)  38.095    0.233318   \n",
       "1   Bagging Regressor (DT)   (100, 10, 20, True, False)  38.095    0.213632   \n",
       "2   Bagging Regressor (DT)   (100, 10, 20, False, True)  33.333    0.212461   \n",
       "3   Bagging Regressor (DT)  (100, 10, 20, False, False)  38.095    0.211680   \n",
       "4   Bagging Regressor (DT)    (100, 10, 50, True, True)  47.619    0.480269   \n",
       "5   Bagging Regressor (DT)   (100, 10, 50, True, False)  33.333    0.468580   \n",
       "6   Bagging Regressor (DT)   (100, 10, 50, False, True)  42.857    0.467698   \n",
       "7   Bagging Regressor (DT)  (100, 10, 50, False, False)  38.095    0.462829   \n",
       "8   Bagging Regressor (DT)    (100, 10, 60, True, True)  42.857    0.577932   \n",
       "9   Bagging Regressor (DT)   (100, 10, 60, True, False)  42.857    0.586996   \n",
       "10  Bagging Regressor (DT)   (100, 10, 60, False, True)  33.333    0.591305   \n",
       "11  Bagging Regressor (DT)  (100, 10, 60, False, False)  38.095    0.597226   \n",
       "12  Bagging Regressor (DT)    (100, 20, 20, True, True)  42.857    0.211228   \n",
       "13  Bagging Regressor (DT)   (100, 20, 20, True, False)  42.857    0.211595   \n",
       "14  Bagging Regressor (DT)   (100, 20, 20, False, True)  42.857    0.226894   \n",
       "15  Bagging Regressor (DT)  (100, 20, 20, False, False)  42.857    0.213197   \n",
       "16  Bagging Regressor (DT)    (100, 20, 50, True, True)  42.857    0.458122   \n",
       "17  Bagging Regressor (DT)   (100, 20, 50, True, False)  47.619    0.469801   \n",
       "18  Bagging Regressor (DT)   (100, 20, 50, False, True)  38.095    0.475078   \n",
       "19  Bagging Regressor (DT)  (100, 20, 50, False, False)  47.619    0.463000   \n",
       "20  Bagging Regressor (DT)    (100, 20, 60, True, True)  33.333    0.607960   \n",
       "21  Bagging Regressor (DT)   (100, 20, 60, True, False)  38.095    0.586441   \n",
       "22  Bagging Regressor (DT)   (100, 20, 60, False, True)  33.333    0.584668   \n",
       "23  Bagging Regressor (DT)  (100, 20, 60, False, False)  38.095    0.588140   \n",
       "24  Bagging Regressor (DT)    (100, 30, 20, True, True)  33.333    0.214778   \n",
       "25  Bagging Regressor (DT)   (100, 30, 20, True, False)  52.381    0.211576   \n",
       "26  Bagging Regressor (DT)   (100, 30, 20, False, True)  33.333    0.218099   \n",
       "27  Bagging Regressor (DT)  (100, 30, 20, False, False)  52.381    0.218288   \n",
       "28  Bagging Regressor (DT)    (100, 30, 50, True, True)  42.857    0.458911   \n",
       "29  Bagging Regressor (DT)   (100, 30, 50, True, False)  42.857    0.474571   \n",
       "30  Bagging Regressor (DT)   (100, 30, 50, False, True)  42.857    0.472724   \n",
       "31  Bagging Regressor (DT)  (100, 30, 50, False, False)  42.857    0.485122   \n",
       "32  Bagging Regressor (DT)    (100, 30, 60, True, True)  38.095    0.595225   \n",
       "33  Bagging Regressor (DT)   (100, 30, 60, True, False)  33.333    0.605169   \n",
       "34  Bagging Regressor (DT)   (100, 30, 60, False, True)  38.095    0.598013   \n",
       "35  Bagging Regressor (DT)  (100, 30, 60, False, False)  33.333    0.610230   \n",
       "36  Bagging Regressor (DT)    (200, 10, 20, True, True)  33.333    0.413500   \n",
       "37  Bagging Regressor (DT)   (200, 10, 20, True, False)  33.333    0.426104   \n",
       "38  Bagging Regressor (DT)   (200, 10, 20, False, True)  33.333    0.421968   \n",
       "39  Bagging Regressor (DT)  (200, 10, 20, False, False)  33.333    0.414768   \n",
       "40  Bagging Regressor (DT)    (200, 10, 50, True, True)  66.667    0.924459   \n",
       "41  Bagging Regressor (DT)   (200, 10, 50, True, False)  38.095    0.934540   \n",
       "42  Bagging Regressor (DT)   (200, 10, 50, False, True)  61.905    0.918467   \n",
       "43  Bagging Regressor (DT)  (200, 10, 50, False, False)  38.095    0.915788   \n",
       "44  Bagging Regressor (DT)    (200, 10, 60, True, True)  33.333    1.191411   \n",
       "45  Bagging Regressor (DT)   (200, 10, 60, True, False)  38.095    1.179926   \n",
       "46  Bagging Regressor (DT)   (200, 10, 60, False, True)  33.333    1.174052   \n",
       "47  Bagging Regressor (DT)  (200, 10, 60, False, False)  38.095    1.199397   \n",
       "48  Bagging Regressor (DT)    (200, 20, 20, True, True)  38.095    0.416047   \n",
       "49  Bagging Regressor (DT)   (200, 20, 20, True, False)  38.095    0.424252   \n",
       "\n",
       "    test_time  \n",
       "0    0.353067  \n",
       "1    0.354575  \n",
       "2    0.357825  \n",
       "3    0.353857  \n",
       "4    0.346802  \n",
       "5    0.346213  \n",
       "6    0.347006  \n",
       "7    0.349061  \n",
       "8    0.353337  \n",
       "9    0.347714  \n",
       "10   0.348392  \n",
       "11   0.360252  \n",
       "12   0.339423  \n",
       "13   0.361912  \n",
       "14   0.341176  \n",
       "15   0.350047  \n",
       "16   0.346450  \n",
       "17   0.348179  \n",
       "18   0.346943  \n",
       "19   0.366208  \n",
       "20   0.361641  \n",
       "21   0.346637  \n",
       "22   0.357027  \n",
       "23   0.347868  \n",
       "24   0.341378  \n",
       "25   0.353158  \n",
       "26   0.347623  \n",
       "27   0.350863  \n",
       "28   0.344267  \n",
       "29   0.355489  \n",
       "30   0.344054  \n",
       "31   0.345893  \n",
       "32   0.342590  \n",
       "33   0.344667  \n",
       "34   0.344473  \n",
       "35   0.347696  \n",
       "36   0.484519  \n",
       "37   0.472942  \n",
       "38   0.472197  \n",
       "39   0.470777  \n",
       "40   0.477019  \n",
       "41   0.475284  \n",
       "42   0.473058  \n",
       "43   0.477709  \n",
       "44   0.487758  \n",
       "45   0.486977  \n",
       "46   0.475252  \n",
       "47   0.491126  \n",
       "48   0.476726  \n",
       "49   0.469221  "
      ]
     },
     "execution_count": 496,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "running_score = pd.DataFrame(scoring_raw)\n",
    "running_score.score.value_counts()\n",
    "running_score.head(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3ffd36e-c9f7-44d9-bc17-09b4581d2371",
   "metadata": {},
   "source": [
    "#### ExtraTrees Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "d61bea2a-3a15-400b-bb03-2da7e9e823f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extratrees_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_depth': [10],\n",
    "            'min_samples_split': [2,4,6],\n",
    "            'min_samples_leaf': [1,3,5],\n",
    "            'max_features': ['auto','sqrt','log2']}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "            for max_depth in params['max_depth']:\n",
    "                for min_samples_split in params['min_samples_split']:\n",
    "                    for min_samples_leaf in params['min_samples_leaf']:\n",
    "                        for max_features in params['max_features']:\n",
    "                            start = timer()\n",
    "                            model_params = (n_estimators, max_depth, min_samples_split, min_samples_leaf, max_features)\n",
    "                            model = ExtraTreesRegressor(random_state=0, n_estimators=n_estimators,\n",
    "                                                        max_depth=max_depth, min_samples_split=min_samples_split,\n",
    "                                                        min_samples_leaf=min_samples_leaf, max_features=max_features)\n",
    "                            model.fit(X_train, y_train)\n",
    "                            end = timer()\n",
    "                            scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                            start = timer()\n",
    "                            model_score = regression_test_score(model)\n",
    "                            end = timer()\n",
    "\n",
    "                            scoring_raw['model'].append('Extra Trees Regressor')\n",
    "                            scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                            scoring_raw['params'].append(model_params)\n",
    "                            scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ea13d1-d07a-4520-935c-4ef46d154098",
   "metadata": {},
   "source": [
    "#### Gradient Boosting Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "2494c056-91da-4470-9f91-fa066f149d1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradientboosting_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'learning_rate': [0.001,0.01,0.1,1],\n",
    "            'subsample': [0.001,0.1,1],\n",
    "            'max_depth': [5,10,20]}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "            for learning_rate in params['learning_rate']:\n",
    "                for subsample in params['subsample']:\n",
    "                        for max_depth in params['max_depth']:\n",
    "                            start = timer()\n",
    "                            model_params = (n_estimators, learning_rate, subsample, max_depth)\n",
    "                            model = GradientBoostingRegressor(random_state=0, n_estimators=n_estimators,\n",
    "                                                        learning_rate=learning_rate, subsample=subsample,\n",
    "                                                         max_depth=max_depth)\n",
    "                            model.fit(X_train, y_train)\n",
    "                            end = timer()\n",
    "                            scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                            start = timer()\n",
    "                            model_score = regression_test_score(model)\n",
    "                            end = timer()\n",
    "\n",
    "                            scoring_raw['model'].append('Gradient Boosting Regressor')\n",
    "                            scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                            scoring_raw['params'].append(model_params)\n",
    "                            scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6f6b8fd-2839-4ce5-b5fc-e12531dfa2bd",
   "metadata": {},
   "source": [
    "#### Random Forest Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "8ce341c2-25d4-4b01-bb0e-7427fe42287e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_forest_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_depth': [10],\n",
    "            'min_samples_split': [2,4,6],\n",
    "            'min_samples_leaf': [1,3,5],\n",
    "            'max_features': ['auto','sqrt','log2']}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for max_depth in params['max_depth']:\n",
    "            for min_samples_split in params['min_samples_split']:\n",
    "                for min_samples_leaf in params['min_samples_leaf']:\n",
    "                    for max_features in params['max_features']:\n",
    "                        start = timer()\n",
    "                        model_params = (n_estimators, max_depth, min_samples_split, min_samples_leaf, max_features)\n",
    "                        model = RandomForestRegressor(random_state=0, n_estimators=n_estimators, max_depth=max_depth,\n",
    "                                                     min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf,\n",
    "                                                     max_features=max_features)\n",
    "                        model.fit(X_train, y_train)\n",
    "                        end = timer()\n",
    "                        scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                        start = timer()\n",
    "                        model_score = regression_test_score(model)\n",
    "                        end = timer()\n",
    "\n",
    "                        scoring_raw['model'].append('Random Forest Regressor')\n",
    "                        scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                        scoring_raw['params'].append(model_params)\n",
    "                        scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fa6a704-a3dd-464e-b29f-deec542a5e95",
   "metadata": {},
   "source": [
    "#### Stacking Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "8423fdbd-876e-4476-80b0-04fcd4563536",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stacking_regressor(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_depth': [10]}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for max_depth in params['max_depth']:\n",
    "            start = timer()\n",
    "            model_params = (n_estimators, max_depth)\n",
    "            estimators = [('lr', RidgeCV()),('adr', ARDRegression())]\n",
    "            model = StackingRegressor(estimators=estimators,\n",
    "                                      final_estimator=RandomForestRegressor(random_state=0, n_estimators=n_estimators, max_depth=max_depth))\n",
    "            model.fit(X_train, y_train)\n",
    "            end = timer()\n",
    "            scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "            start = timer()\n",
    "            model_score = regression_test_score(model)\n",
    "            end = timer()\n",
    "\n",
    "            scoring_raw['model'].append('Stacking Regressor (RF)')\n",
    "            scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "            scoring_raw['params'].append(model_params)\n",
    "            scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78ec85b4-e1e7-437e-9dca-4ab87bc4b7fd",
   "metadata": {},
   "source": [
    "#### Neural Network - MLP Regressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "d2607170-1db7-47eb-b3f1-3fcc2ee87685",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mlp_regressor(X_train, y_train):\n",
    "    params={\n",
    "        'hidden_layer_sizes': [(80,20,40,5), (75,30,50,10,3)], \n",
    "        'activation': ['identity', 'relu','logistic',], \n",
    "        'solver': ['lbfgs','sgd', 'adam'], \n",
    "        'alpha': np.logspace(-4,1,10)}\n",
    "\n",
    "    for hidden_layer_sizes in params['hidden_layer_sizes']:\n",
    "        for activation in params['activation']:\n",
    "            for solver in params['solver']:\n",
    "                for alpha in params['alpha']:\n",
    "                    start = timer()\n",
    "                    model_params = (hidden_layer_sizes, activation, solver, alpha)\n",
    "                    model = MLPRegressor(random_state=1, max_iter=500, hidden_layer_sizes=hidden_layer_sizes,\n",
    "                                        activation=activation, solver=solver, alpha=alpha)\n",
    "                    model.fit(X_train, y_train)\n",
    "                    end = timer()\n",
    "                    scoring_raw['train_time'].append(end - start)\n",
    "\n",
    "                    start = timer()\n",
    "                    model_score = regression_test_score(model)\n",
    "                    end = timer()\n",
    "\n",
    "                    scoring_raw['model'].append('Neural Network - MLP Regressor')\n",
    "                    scoring_raw['score'].append(np.round(model_score*100, 3))\n",
    "                    scoring_raw['params'].append(model_params)\n",
    "                    scoring_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "ce5294b4-b04a-4176-b736-e14fff55b60a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_raw ={'model':[], 'params': [], 'score': [], 'train_time': [], 'test_time': []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "7bcce6ec-0053-4f24-9808-b9ebdc794584",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Dumb Classifier\n",
      "Dumb Classifier done => 0.1877s.\n",
      "Running Linear Regression\n",
      "Linear Regression done => 0.4183s.\n",
      "Running AdaBoost Regressor\n",
      "AdaBoost Regressor done => 332.6744s.\n",
      "Running Bagging Regressor\n",
      "Bagging Regressor done => 134.8787s.\n",
      "Running Gradient Boosting Regressor\n",
      "Gradient Boosting Regressor done => 1111.0537s.\n",
      "Running Random Forest Regressor\n",
      "Random Forest Regressor done => 585.9226s.\n",
      "Running Stacking Regressor (RF)\n",
      "Stacking Regressor (RF) done => 16.3893s.\n",
      "Running Neural Network (MLP Regressor)\n",
      "Neural Network (MLP Regressor) done => 1744.2518s.\n",
      "Running all regressors: 3925.7784s\n"
     ]
    },
    {
     "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</th>\n",
       "      <th>params</th>\n",
       "      <th>score</th>\n",
       "      <th>train_time</th>\n",
       "      <th>test_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Jose's Dumb Classifier</td>\n",
       "      <td>none</td>\n",
       "      <td>9.524</td>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.187482</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Linear Regression</td>\n",
       "      <td>True</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.037792</td>\n",
       "      <td>0.181738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Linear Regression</td>\n",
       "      <td>False</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.020009</td>\n",
       "      <td>0.178630</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AdaBoost Regressor</td>\n",
       "      <td>(100, 0.001, linear)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>7.460298</td>\n",
       "      <td>0.315744</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>AdaBoost Regressor</td>\n",
       "      <td>(100, 0.001, square)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>7.335898</td>\n",
       "      <td>0.278544</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>514</th>\n",
       "      <td>Neural Network - MLP Regressor</td>\n",
       "      <td>((75, 30, 50, 10, 3), logistic, adam, 0.059948...</td>\n",
       "      <td>0.000</td>\n",
       "      <td>2.893149</td>\n",
       "      <td>0.199185</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>515</th>\n",
       "      <td>Neural Network - MLP Regressor</td>\n",
       "      <td>((75, 30, 50, 10, 3), logistic, adam, 0.215443...</td>\n",
       "      <td>4.762</td>\n",
       "      <td>3.605735</td>\n",
       "      <td>0.191327</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>516</th>\n",
       "      <td>Neural Network - MLP Regressor</td>\n",
       "      <td>((75, 30, 50, 10, 3), logistic, adam, 0.774263...</td>\n",
       "      <td>4.762</td>\n",
       "      <td>4.389698</td>\n",
       "      <td>0.197765</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>517</th>\n",
       "      <td>Neural Network - MLP Regressor</td>\n",
       "      <td>((75, 30, 50, 10, 3), logistic, adam, 2.782559...</td>\n",
       "      <td>0.000</td>\n",
       "      <td>5.892418</td>\n",
       "      <td>0.195098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>518</th>\n",
       "      <td>Neural Network - MLP Regressor</td>\n",
       "      <td>((75, 30, 50, 10, 3), logistic, adam, 10.0)</td>\n",
       "      <td>0.000</td>\n",
       "      <td>5.196142</td>\n",
       "      <td>0.194635</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>519 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                              model  \\\n",
       "0            Jose's Dumb Classifier   \n",
       "1                 Linear Regression   \n",
       "2                 Linear Regression   \n",
       "3                AdaBoost Regressor   \n",
       "4                AdaBoost Regressor   \n",
       "..                              ...   \n",
       "514  Neural Network - MLP Regressor   \n",
       "515  Neural Network - MLP Regressor   \n",
       "516  Neural Network - MLP Regressor   \n",
       "517  Neural Network - MLP Regressor   \n",
       "518  Neural Network - MLP Regressor   \n",
       "\n",
       "                                                params   score  train_time  \\\n",
       "0                                                 none   9.524    0.000002   \n",
       "1                                                 True  38.095    0.037792   \n",
       "2                                                False  38.095    0.020009   \n",
       "3                                 (100, 0.001, linear)  47.619    7.460298   \n",
       "4                                 (100, 0.001, square)  47.619    7.335898   \n",
       "..                                                 ...     ...         ...   \n",
       "514  ((75, 30, 50, 10, 3), logistic, adam, 0.059948...   0.000    2.893149   \n",
       "515  ((75, 30, 50, 10, 3), logistic, adam, 0.215443...   4.762    3.605735   \n",
       "516  ((75, 30, 50, 10, 3), logistic, adam, 0.774263...   4.762    4.389698   \n",
       "517  ((75, 30, 50, 10, 3), logistic, adam, 2.782559...   0.000    5.892418   \n",
       "518        ((75, 30, 50, 10, 3), logistic, adam, 10.0)   0.000    5.196142   \n",
       "\n",
       "     test_time  \n",
       "0     0.187482  \n",
       "1     0.181738  \n",
       "2     0.178630  \n",
       "3     0.315744  \n",
       "4     0.278544  \n",
       "..         ...  \n",
       "514   0.199185  \n",
       "515   0.191327  \n",
       "516   0.197765  \n",
       "517   0.195098  \n",
       "518   0.194635  \n",
       "\n",
       "[519 rows x 5 columns]"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# run all Regressors + the Dumb Classifier\n",
    "regressors = [('Dumb Classifier', joses_dumb_classifier),\n",
    "              ('Linear Regression', linear_regression),\n",
    "              ('AdaBoost Regressor', adaboost_regressor),\n",
    "              ('Bagging Regressor', bagging_regressor),\n",
    "              ('Gradient Boosting Regressor', gradientboosting_regressor),\n",
    "              ('Random Forest Regressor', random_forest_regressor),\n",
    "              ('Stacking Regressor (RF)', stacking_regressor),\n",
    "              ('Neural Network (MLP Regressor)', mlp_regressor)]\n",
    "\n",
    "start = timer()\n",
    "for regressor in regressors:\n",
    "    start_reg = timer()\n",
    "    print(f'Running {regressor[0]}')\n",
    "    regressor[1](X_train, y_train)\n",
    "    end_reg = timer()\n",
    "    print(f'{regressor[0]} done => {np.round(end_reg - start_reg, 4)}s.')\n",
    "end = timer()\n",
    "\n",
    "print(f'Running all regressors: {np.round(end - start, 4)}s')\n",
    "running_score = pd.DataFrame(scoring_raw)\n",
    "running_score\n",
    "\n",
    "running_score.to_csv('regressions_scores.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8d89384-5c88-4142-8400-6687f0fe423a",
   "metadata": {},
   "source": [
    "<a id='classification_approaches'></a>\n",
    "### Classification Approaches\n",
    "\n",
    "This problem can also be approached as a classification problem since we want to predict 2 categories - the race winner, and then everybody else. Like the Regression problem, we will need to submit the details for the 20 competitors, wherein the classification algorithm will predict if the driver WILL WIN, or NOT WIN. Because this produces 2 columns of probabilities for all competitors, we can then simply sort this, and the one with the highest probability of winning will be our winner. \n",
    "\n",
    "The following classification models were used:\n",
    "\n",
    "- Logistic Regression\n",
    "- Random Forest Classifier\n",
    "- SVM Classifier\n",
    "- Ada Boost Classifier\n",
    "- Extra Trees  Classifier\n",
    "- Gradient Boosting\n",
    "- Stacking Classifier\n",
    "- Neural Networks (MLP Classifier)\n",
    "\n",
    "<img src=\"./presentation/reveal.js/images/f1-classification-approach.png\" width=\"600\" height=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4369c6aa-ba12-49a5-8e21-8022e2b33557",
   "metadata": {},
   "source": [
    "#### Classification Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "253fb4b5-9045-411e-80f8-9e2c95fbe41b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "def classification_test_score(model):\n",
    "    # --- Test ---\n",
    "    score = 0\n",
    "    races = model_df[(model_df['Season'] == 2021)]['Round'].unique()\n",
    "    for race in races:\n",
    "        test = model_df[(model_df['Season'] == 2021) & (model_df['Round'] == race)]\n",
    "        X_test = test.drop(['Position','Driver'], axis = 1)\n",
    "        y_test = test['Position']\n",
    "        X_test = pd.DataFrame(scaler.transform(X_test), columns = X_test.columns)\n",
    "\n",
    "        # make predictions\n",
    "        prediction_df = pd.DataFrame(model.predict_proba(X_test), columns = ['proba_not_win', 'proba_win'])\n",
    "        merged_df = pd.concat([prediction_df, test[['Driver','Position']].reset_index(drop=True)], axis=1)\n",
    "        merged_df.rename(columns = {'Position': 'actual_pos'}, inplace = True)\n",
    "        \n",
    "        # shuffle data to remove original order that will influence selection\n",
    "        # of race winner when there are drivers with identical win probablilities\n",
    "        merged_df = merged_df.sample(frac=1).reset_index(drop=True)\n",
    "        merged_df.sort_values(by='proba_win', ascending=False, inplace=True)\n",
    "        merged_df['predicted_pos'] = 0\n",
    "        merged_df.iloc[0, merged_df.columns.get_loc('predicted_pos')] = 1\n",
    "        merged_df.reset_index(drop=True, inplace=True)\n",
    "        \n",
    "        # --- Score ---\n",
    "        score += precision_score(merged_df['actual_pos'], merged_df['predicted_pos'], zero_division=0)\n",
    "\n",
    "    return score / len(races)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "efdee945-e431-488a-87c6-48f8f4ae3395",
   "metadata": {},
   "outputs": [],
   "source": [
    "scoring_clf_raw ={'model':[], 'params': [], 'score': [], 'train_time': [], 'test_time': []}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90af902d-4e43-4ca1-b6ee-1bf238b4be0d",
   "metadata": {},
   "source": [
    "#### Logistic Regression\n",
    "\n",
    "I have tried out using [GridSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html?highlight=gridsearchcv#sklearn.model_selection.GridSearchCV) however, the precision score was a bit lower than the manual search, so I reverted to the manual method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "3f430fe2-bedd-403d-9da2-906a14e33357",
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic_regression(X_train, y_train):\n",
    "    params={'penalty': ['l1', 'l2'],\n",
    "            'solver': ['saga', 'liblinear'],\n",
    "            'C': np.logspace(-3,1,20)}\n",
    "\n",
    "    for penalty in params['penalty']:\n",
    "        for solver in params['solver']:\n",
    "            for C in params['C']:\n",
    "                start = timer()\n",
    "                model_params = (penalty, solver, C)\n",
    "                model = LogisticRegression(penalty=penalty, solver=solver, C=C, max_iter = 10000)\n",
    "                model.fit(X_train, y_train)\n",
    "                end = timer()\n",
    "                scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                start = timer()\n",
    "                model_score = classification_test_score(model)\n",
    "                end = timer()\n",
    "\n",
    "                scoring_clf_raw['model'].append('Logistic Regression')\n",
    "                scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                scoring_clf_raw['params'].append(model_params)\n",
    "                scoring_clf_raw['test_time'].append(end - start)\n",
    "\n",
    "def logistic_regression_grid(X_train, y_train):\n",
    "    params={'penalty': ['l1', 'l2'],\n",
    "            'solver': ['saga', 'liblinear'],\n",
    "            'C': np.logspace(-3,1,20)}\n",
    "    \n",
    "    start = timer()\n",
    "    model = GridSearchCV(LogisticRegression(max_iter = 10000), params, cv=2)\n",
    "    model.fit(X_train, y_train)\n",
    "    end = timer()\n",
    "    scoring_clf_raw['train_time'].append(end - start)\n",
    "        \n",
    "    start = timer()\n",
    "    model_score = classification_test_score(model)\n",
    "    end = timer()\n",
    "    scoring_clf_raw['model'].append('Logistic Regression')\n",
    "    scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "    scoring_clf_raw['params'].append(model.best_params_)\n",
    "    scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c05aa471-b5ad-47c0-8d07-f8bfc2582a6b",
   "metadata": {},
   "source": [
    "#### Random Forest Classifier\n",
    "\n",
    "Like in Logistic Regression, I have tried out using [GridSearchCV](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html?highlight=gridsearchcv#sklearn.model_selection.GridSearchCV) however, the precision score was a bit lower than the manual search, so I reverted to the manual method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "ad8e1e85-d9a2-427d-94f0-f9cf96611f65",
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_forest_classifier(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_depth': [10],\n",
    "            'min_samples_split': [2,4,6],\n",
    "            'min_samples_leaf': [1,3,5],\n",
    "            'max_features': ['auto','sqrt','log2']}\n",
    "\n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for max_depth in params['max_depth']:\n",
    "            for min_samples_split in params['min_samples_split']:\n",
    "                for min_samples_leaf in params['min_samples_leaf']:\n",
    "                    for max_features in params['max_features']:\n",
    "                        start = timer()\n",
    "                        model_params = (n_estimators, max_depth, min_samples_split, min_samples_leaf, max_features)\n",
    "                        model = RandomForestClassifier(random_state=0, n_estimators=n_estimators, max_depth=max_depth,\n",
    "                                                     min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf,\n",
    "                                                     max_features=max_features)\n",
    "                        model.fit(X_train, y_train)\n",
    "                        end = timer()\n",
    "                        scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                        start = timer()\n",
    "                        model_score = classification_test_score(model)\n",
    "                        end = timer()\n",
    "\n",
    "                        scoring_clf_raw['model'].append('Random Forest Classifier')\n",
    "                        scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                        scoring_clf_raw['params'].append(model_params)\n",
    "                        scoring_clf_raw['test_time'].append(end - start)\n",
    "        \n",
    "\n",
    "def random_forest_classifier_grid(X_train, y_train):\n",
    "    params={'n_estimators': [100,200,300],\n",
    "            'max_depth': [10],\n",
    "            'min_samples_split': [2,4,6],\n",
    "            'min_samples_leaf': [1,3,5],\n",
    "            'max_features': ['auto','sqrt','log2']}\n",
    "    \n",
    "    start = timer()\n",
    "    model = GridSearchCV(RandomForestClassifier(random_state=0), params)\n",
    "    model.fit(X_train, y_train)\n",
    "    end = timer()\n",
    "    scoring_clf_raw['train_time'].append(end - start)\n",
    "        \n",
    "    start = timer()\n",
    "    model_score = classification_test_score(model)\n",
    "    end = timer()\n",
    "    scoring_clf_raw['model'].append('Random Forest Classifier')\n",
    "    scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "    scoring_clf_raw['params'].append(model.best_params_)\n",
    "    scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "065aa5db-cd15-487b-a324-57905b936a67",
   "metadata": {},
   "source": [
    "#### SVM Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "65974498-bb6e-43f9-9007-1cbc32364aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "def svm_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'gamma': np.logspace(-4, -1, 3),\n",
    "        'C': np.logspace(-2, 1, 3),\n",
    "        'kernel': ['linear']}\n",
    "    \n",
    "    for gamma in params['gamma']:\n",
    "        for C in params['C']:\n",
    "            for kernel in params['kernel']:\n",
    "                start = timer()\n",
    "                model_params = (gamma, C, kernel)\n",
    "                model = SVC(probability = True, gamma=gamma, C=C, kernel=kernel)\n",
    "                model.fit(X_train, y_train)\n",
    "                end = timer()\n",
    "                scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                start = timer()\n",
    "                model_score = classification_test_score(model)\n",
    "                end = timer()\n",
    "\n",
    "                scoring_clf_raw['model'].append('SVM Classifier')\n",
    "                scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                scoring_clf_raw['params'].append(model_params)\n",
    "                scoring_clf_raw['test_time'].append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ece93b8-a186-4949-8cf1-6c28b6cc1c79",
   "metadata": {},
   "source": [
    "#### AdaBoost Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "4fdae65b-2e26-4994-bcd8-a5b496a4a82b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def adaboost_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'n_estimators': [100,200,300],\n",
    "        'learning_rate': [0.001,0.01,0.1,1],\n",
    "        'algorithm': ['SAMME', 'SAMME.R']}\n",
    "    \n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for learning_rate in params['learning_rate']:\n",
    "            for algorithm in params['algorithm']:\n",
    "                start = timer()\n",
    "                model_params = (n_estimators, learning_rate, algorithm)\n",
    "                model = AdaBoostClassifier(random_state=0, n_estimators=n_estimators, \n",
    "                                          learning_rate=learning_rate, algorithm=algorithm)\n",
    "                model.fit(X_train, y_train)\n",
    "                end = timer()\n",
    "                scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                start = timer()\n",
    "                model_score = classification_test_score(model)\n",
    "                end = timer()\n",
    "\n",
    "                scoring_clf_raw['model'].append('Ada Boost Classifier')\n",
    "                scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                scoring_clf_raw['params'].append(model_params)\n",
    "                scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1abdf32c-41e7-42a4-b483-df1c52311de3",
   "metadata": {},
   "source": [
    "#### ExtraTrees Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "c1f869e3-062a-449a-9bba-e36c97662177",
   "metadata": {},
   "outputs": [],
   "source": [
    "def extratrees_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'n_estimators': [100,200,300],\n",
    "        'max_depth': [10],\n",
    "        'min_samples_split': [2,4,6],\n",
    "        'min_samples_leaf': [1,3,5],\n",
    "        'max_features': ['auto','sqrt','log2']}\n",
    "    \n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for max_depth in params['max_depth']:\n",
    "            for min_samples_split in params['min_samples_split']:\n",
    "                for min_samples_leaf in params['min_samples_leaf']:\n",
    "                    for max_features in params['max_features']:\n",
    "                        start = timer()\n",
    "                        model_params = (n_estimators, max_depth, min_samples_split, min_samples_leaf, max_features)\n",
    "                        model = ExtraTreesClassifier(random_state=0, n_estimators=n_estimators,\n",
    "                                                     max_depth=max_depth, min_samples_split=min_samples_split, min_samples_leaf=min_samples_leaf,\n",
    "                                                     max_features=max_features)\n",
    "                        model.fit(X_train, y_train)\n",
    "                        end = timer()\n",
    "                        scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                        start = timer()\n",
    "                        model_score = classification_test_score(model)\n",
    "                        end = timer()\n",
    "\n",
    "                        scoring_clf_raw['model'].append('Extra Trees Classifier')\n",
    "                        scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                        scoring_clf_raw['params'].append(model_params)\n",
    "                        scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "834db71c-5c41-4649-a901-a4da0d0eac12",
   "metadata": {},
   "source": [
    "#### GradientBoosting Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "96ad39a8-4954-4d87-8af2-9bcec612aaf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_boosting_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'n_estimators': [100,200,300],\n",
    "        'learning_rate': [0.001,0.01,0.1,1],\n",
    "        'subsample': [0.001,0.1,1],\n",
    "        'max_depth': [5,10,20]}\n",
    "    \n",
    "    for n_estimators in params['n_estimators']:\n",
    "        for learning_rate in params['learning_rate']:\n",
    "            for subsample in params['subsample']:\n",
    "                for max_depth in params['max_depth']:\n",
    "                    start = timer()\n",
    "                    model_params = (n_estimators, learning_rate, subsample, max_depth)\n",
    "                    model = GradientBoostingClassifier(random_state=0, n_estimators=n_estimators,\n",
    "                                                 learning_rate=learning_rate, subsample=subsample, max_depth=max_depth)\n",
    "                    model.fit(X_train, y_train)\n",
    "                    end = timer()\n",
    "                    scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                    start = timer()\n",
    "                    model_score = classification_test_score(model)\n",
    "                    end = timer()\n",
    "\n",
    "                    scoring_clf_raw['model'].append('Gradient Boosting Classifier')\n",
    "                    scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                    scoring_clf_raw['params'].append(model_params)\n",
    "                    scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f94119c9-cd6c-4d14-ae19-0e578a93fd83",
   "metadata": {},
   "source": [
    "#### Stacking Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "52997d2a-6490-4dc4-97f6-2941f64adccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def stacking_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'n_estimators': [100,200,300]}\n",
    "    \n",
    "    for n_estimators in params['n_estimators']:\n",
    "        start = timer()\n",
    "        model_params = (n_estimators)\n",
    "        estimators = [('rf', RandomForestClassifier(n_estimators=n_estimators, random_state=42)),\n",
    "                  ('svr', LinearSVC(random_state=45))]\n",
    "\n",
    "        model = StackingClassifier(estimators=estimators, final_estimator=LogisticRegression())\n",
    "        model.fit(X_train, y_train)\n",
    "        end = timer()\n",
    "        scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "        start = timer()\n",
    "        model_score = classification_test_score(model)\n",
    "        end = timer()\n",
    "\n",
    "        scoring_clf_raw['model'].append('Stacking Classifier')\n",
    "        scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "        scoring_clf_raw['params'].append(model_params)\n",
    "        scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ae1a022-a65b-47cc-aa82-7bdf5a01e8ae",
   "metadata": {},
   "source": [
    "#### Neural Network (MLP Classifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "2e4021da-8eda-4efc-81d2-eef41d8ba290",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mlp_classifier(X_train, y_train):\n",
    "    params={\n",
    "        'hidden_layer_sizes': [(80,20,40,5), (75,30,50,10,3)], \n",
    "        'activation': ['identity', 'relu','logistic',], \n",
    "        'solver': ['lbfgs','sgd', 'adam'], \n",
    "        'alpha': np.logspace(-4,1,5)}\n",
    "    \n",
    "    for hidden_layer_sizes in params['hidden_layer_sizes']:\n",
    "        for activation in params['activation']:\n",
    "            for solver in params['solver']:\n",
    "                for alpha in params['alpha']:\n",
    "                    start = timer()\n",
    "                    model_params = (hidden_layer_sizes, activation, solver, alpha)\n",
    "                    model = MLPClassifier(hidden_layer_sizes=hidden_layer_sizes, activation=activation, solver=solver, alpha=alpha, max_iter=20)\n",
    "                    model.fit(X_train, y_train)\n",
    "                    end = timer()\n",
    "                    scoring_clf_raw['train_time'].append(end - start)\n",
    "\n",
    "                    start = timer()\n",
    "                    model_score = classification_test_score(model)\n",
    "                    end = timer()\n",
    "\n",
    "                    scoring_clf_raw['model'].append('Neural Network (MLP Classifier)')\n",
    "                    scoring_clf_raw['score'].append(np.round(model_score*100, 3))\n",
    "                    scoring_clf_raw['params'].append(model_params)\n",
    "                    scoring_clf_raw['test_time'].append(end - start)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "76527677-eed0-464b-89ca-cc844cc5876b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Logistic Regression\n",
      "Logistic Regression done => 35.1231s.\n",
      "Running Random Forest Classifier\n",
      "Random Forest Classifier done => 250.337s.\n",
      "Running Neural Network (MLP Classifier)\n",
      "Neural Network (MLP Classifier) done => 235.9248s.\n",
      "Running AdaBoost Classifier\n",
      "AdaBoost Classifier done => 109.1923s.\n",
      "Running Extra Trees Classifier\n",
      "Extra Trees Classifier done => 200.5558s.\n",
      "Running Gradient Boosting Classifier\n",
      "Gradient Boosting Classifier done => 1413.9461s.\n",
      "Running Stacking Classifier\n",
      "Stacking Classifier done => 62.2184s.\n",
      "Running all classifiers: 2307.3023s\n"
     ]
    }
   ],
   "source": [
    "# run all Classifiers (more than 8 hours!)\n",
    "classifiers = [\n",
    "    ('Logistic Regression', logistic_regression),\n",
    "    ('Random Forest Classifier', random_forest_classifier),\n",
    "    ('Neural Network (MLP Classifier)', mlp_classifier),              \n",
    "    ('AdaBoost Classifier', adaboost_classifier),\n",
    "    ('Extra Trees Classifier', extratrees_classifier),\n",
    "    ('Gradient Boosting Classifier', gradient_boosting_classifier),\n",
    "    ('Stacking Classifier', stacking_classifier),\n",
    "    # ('SVM Classifier', svm_classifier) => removed as takes a few hours, and with similar results as other models\n",
    "]\n",
    "\n",
    "start = timer()\n",
    "for classifier in classifiers:\n",
    "    start_clf = timer()\n",
    "    print(f'Running {classifier[0]}')\n",
    "    classifier[1](X_train, y_train)\n",
    "    end_clf = timer()\n",
    "    print(f'{classifier[0]} done => {np.round(end_clf - start_clf, 4)}s.')\n",
    "end = timer()\n",
    "\n",
    "print(f'Running all classifiers: {np.round(end - start, 4)}s')\n",
    "running_score = pd.DataFrame(scoring_clf_raw)\n",
    "\n",
    "running_score.to_csv('classification_scores.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6fdae0d-4ba5-4214-8810-fb1dd3d44a08",
   "metadata": {},
   "source": [
    "<a id='models_comparison'></a>\n",
    "#### Comparing all Machine Learning models used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "id": "2cfa45df-93ad-4596-84da-1c351adf3d5e",
   "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>params</th>\n",
       "      <th>score</th>\n",
       "      <th>train_time</th>\n",
       "      <th>test_time</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bagging Regressor (DT)</th>\n",
       "      <td>(200, 10, 50, True, True)</td>\n",
       "      <td>61.905</td>\n",
       "      <td>0.975334</td>\n",
       "      <td>0.416948</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Neural Network - MLP Regressor</th>\n",
       "      <td>((75, 30, 50, 10, 3), 'identity', 'sgd', 10.0)</td>\n",
       "      <td>61.905</td>\n",
       "      <td>10.226832</td>\n",
       "      <td>0.200022</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Boosting Regressor</th>\n",
       "      <td>(300, 0.1, 0.001, 10)</td>\n",
       "      <td>57.143</td>\n",
       "      <td>0.606889</td>\n",
       "      <td>0.171962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Gradient Boosting Classifier</th>\n",
       "      <td>(200, 0.01, 0.001, 20)</td>\n",
       "      <td>57.143</td>\n",
       "      <td>0.920284</td>\n",
       "      <td>0.166690</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>AdaBoost Regressor</th>\n",
       "      <td>(200, 0.01, 'square')</td>\n",
       "      <td>52.381</td>\n",
       "      <td>14.969050</td>\n",
       "      <td>0.449939</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Random Forest Regressor</th>\n",
       "      <td>(300, 10, 2, 5, 'auto')</td>\n",
       "      <td>52.381</td>\n",
       "      <td>23.799965</td>\n",
       "      <td>0.553645</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ada Boost Classifier</th>\n",
       "      <td>(200, 0.1, 'SAMME')</td>\n",
       "      <td>52.381</td>\n",
       "      <td>3.774158</td>\n",
       "      <td>0.445910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Logistic Regression</th>\n",
       "      <td>('l1', 'liblinear', 0.0069519279617756054)</td>\n",
       "      <td>47.619</td>\n",
       "      <td>0.049125</td>\n",
       "      <td>0.162838</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Neural Network (MLP Classifier)</th>\n",
       "      <td>((80, 20, 40, 5), 'logistic', 'sgd', 0.0017782...</td>\n",
       "      <td>42.857</td>\n",
       "      <td>3.335669</td>\n",
       "      <td>0.208089</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Linear Regression</th>\n",
       "      <td>True</td>\n",
       "      <td>38.095</td>\n",
       "      <td>0.037792</td>\n",
       "      <td>0.181738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stacking Regressor (RF)</th>\n",
       "      <td>(100, 10)</td>\n",
       "      <td>38.095</td>\n",
       "      <td>2.767714</td>\n",
       "      <td>0.325875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Extra Trees Classifier</th>\n",
       "      <td>(100, 10, 2, 1, 'auto')</td>\n",
       "      <td>38.095</td>\n",
       "      <td>1.056110</td>\n",
       "      <td>0.330396</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Random Forest Classifier</th>\n",
       "      <td>(100, 10, 2, 3, 'log2')</td>\n",
       "      <td>38.095</td>\n",
       "      <td>1.189105</td>\n",
       "      <td>0.328895</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stacking Classifier</th>\n",
       "      <td>100</td>\n",
       "      <td>33.333</td>\n",
       "      <td>10.538083</td>\n",
       "      <td>0.374325</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Jose's Dumb Classifier</th>\n",
       "      <td>none</td>\n",
       "      <td>9.524</td>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.187482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                                            params  \\\n",
       "model                                                                                \n",
       "Bagging Regressor (DT)                                   (200, 10, 50, True, True)   \n",
       "Neural Network - MLP Regressor      ((75, 30, 50, 10, 3), 'identity', 'sgd', 10.0)   \n",
       "Gradient Boosting Regressor                                  (300, 0.1, 0.001, 10)   \n",
       "Gradient Boosting Classifier                                (200, 0.01, 0.001, 20)   \n",
       "AdaBoost Regressor                                           (200, 0.01, 'square')   \n",
       "Random Forest Regressor                                    (300, 10, 2, 5, 'auto')   \n",
       "Ada Boost Classifier                                           (200, 0.1, 'SAMME')   \n",
       "Logistic Regression                     ('l1', 'liblinear', 0.0069519279617756054)   \n",
       "Neural Network (MLP Classifier)  ((80, 20, 40, 5), 'logistic', 'sgd', 0.0017782...   \n",
       "Linear Regression                                                             True   \n",
       "Stacking Regressor (RF)                                                  (100, 10)   \n",
       "Extra Trees Classifier                                     (100, 10, 2, 1, 'auto')   \n",
       "Random Forest Classifier                                   (100, 10, 2, 3, 'log2')   \n",
       "Stacking Classifier                                                            100   \n",
       "Jose's Dumb Classifier                                                        none   \n",
       "\n",
       "                                  score  train_time  test_time  \n",
       "model                                                           \n",
       "Bagging Regressor (DT)           61.905    0.975334   0.416948  \n",
       "Neural Network - MLP Regressor   61.905   10.226832   0.200022  \n",
       "Gradient Boosting Regressor      57.143    0.606889   0.171962  \n",
       "Gradient Boosting Classifier     57.143    0.920284   0.166690  \n",
       "AdaBoost Regressor               52.381   14.969050   0.449939  \n",
       "Random Forest Regressor          52.381   23.799965   0.553645  \n",
       "Ada Boost Classifier             52.381    3.774158   0.445910  \n",
       "Logistic Regression              47.619    0.049125   0.162838  \n",
       "Neural Network (MLP Classifier)  42.857    3.335669   0.208089  \n",
       "Linear Regression                38.095    0.037792   0.181738  \n",
       "Stacking Regressor (RF)          38.095    2.767714   0.325875  \n",
       "Extra Trees Classifier           38.095    1.056110   0.330396  \n",
       "Random Forest Classifier         38.095    1.189105   0.328895  \n",
       "Stacking Classifier              33.333   10.538083   0.374325  \n",
       "Jose's Dumb Classifier            9.524    0.000002   0.187482  "
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.ticker as mtick\n",
    "\n",
    "def read_csv_dataframe(filename):\n",
    "    summary = pd.read_csv(filename)\n",
    "    summary.drop(columns=['Unnamed: 0'],inplace=True)\n",
    "    groups = summary.groupby(by=['model'])\n",
    "    summary = groups.apply(lambda x: x[x['score'] == x['score'].max()].iloc[0])\n",
    "    summary.sort_values(by='score', inplace=True)\n",
    "    summary.set_index('model', inplace=True)\n",
    "    return summary\n",
    "\n",
    "summary_df = read_csv_dataframe('regressions_scores.csv')\n",
    "summary_clf_df = read_csv_dataframe('classification_scores.csv')\n",
    "\n",
    "# merge\n",
    "merged_scores_df = pd.concat([summary_df, summary_clf_df])\n",
    "merged_scores_df.sort_values(by='score', inplace=True)\n",
    "merged_scores_df\n",
    "\n",
    "# plot feature importance \n",
    "axis = feature_importance_df.plot(kind='barh', title=\"F1 Prediction Feature Importance\", figsize=(16, 4), color='#05AFF2', grid=True,)\n",
    "y_label = axis.yaxis.get_label()\n",
    "y_label.set_visible(False)\n",
    "\n",
    "# plot precision scores\n",
    "axis = merged_scores_df[['score']].plot(kind='barh', figsize=(16,10), color=['#00CC99','#9370DB','#CA98BF'], grid=True, linestyle='--')\n",
    "axis.xaxis.set_major_formatter(mtick.PercentFormatter())\n",
    "axis.set_title('F1 Prediction Precision Scores', pad=20)\n",
    "y_label = axis.yaxis.get_label()\n",
    "y_label.set_visible(False)\n",
    "merged_scores_df.sort_values(by='score', inplace=True, ascending=False)\n",
    "merged_scores_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f78c83a0-77ca-45d5-9c9e-7e381bfbd28d",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Following our [Champion/Challenger](https://medium.com/@awaiskaleem/mlflow-tips-n-tricks-eb1ac013edd1) model, the winning model is the one built with [Bagging Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingRegressor.html) ([Decision Tree Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html?highlight=decisiontree#sklearn.tree.DecisionTreeRegressor)). This is an ensemble model fron SKLearn which uses DecistionTreeRegressor as its base estimator.\n",
    "\n",
    "[Neural Network - MLP Regressor](https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html?highlight=mlp#sklearn.neural_network.MLPRegressor) ended up with the same precision score, however because it took 10x more in training time, I have delegated it to 2nd place. \n",
    "\n",
    "- **Bagging Regressor (Decision Tree Regressor)**\n",
    "- Train time: **0.97s**\n",
    "- Test time: **0.42s**\n",
    "- **Grid**, **ConstructorRecentForm**, **DriverRecentForm** and **DriverRecentWins** round out the most significant features. The last 3 are one of the features we engineered for this project.\n",
    "- Precision score: **61.9%**\n",
    "- For each race, the finishing order is also available, but omitted here for brevity\n",
    "- Correctly predicting the winner in **13 out of 21** races in 2021 Season\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d2bcc6a-3330-4da3-a7cc-c95236e4667b",
   "metadata": {},
   "source": [
    "### Preparing for Rest API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "288a9f49-ef45-407a-878b-48e4975c9009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66\n",
      "bagging_regressor_pickle took 0.9400396940000064 s\n"
     ]
    }
   ],
   "source": [
    "def bagging_regressor_pickle(X_train, y_train):\n",
    "    # now use the winning paramters to build the model\n",
    "    model = BaggingRegressor(random_state=0, base_estimator=DecisionTreeRegressor(),\n",
    "         n_estimators=200, max_samples=10, max_features=50, bootstrap=True, bootstrap_features=True)\n",
    "    model.fit(X_train, y_train)\n",
    "    pickle.dump(model, open('f1-model.pkl', 'wb'))\n",
    "    print(model.n_features_in_)\n",
    "    \n",
    "\n",
    "start = timer()\n",
    "bagging_regressor_pickle(X_train, y_train)\n",
    "end = timer()\n",
    "print(f'bagging_regressor_pickle took {end - start} s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "6e917f1b-63ba-4892-8719-1ac13903343b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5714285714285714\n",
      "0.5714285714285714\n",
      "0.6190476190476191\n",
      "0.6190476190476191\n",
      "0.5714285714285714\n",
      "0.6190476190476191\n",
      "0.5238095238095238\n",
      "0.6190476190476191\n",
      "0.6666666666666666\n",
      "0.6190476190476191\n",
      "bagging_regressor_inference took 4.709704332999536 s\n"
     ]
    }
   ],
   "source": [
    "start = timer()\n",
    "from_pickled_model = pickle.load(open('f1-model.pkl', 'rb'))\n",
    "for i in range(0, 10):\n",
    "    f1_model_score = regression_test_score(from_pickled_model)\n",
    "    print(f1_model_score)\n",
    "end = timer()\n",
    "print(f'bagging_regressor_inference took {end - start} s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 637,
   "id": "5c7c7681-182a-42b8-9d4e-1808ebeaf32a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(25380, 68)"
      ]
     },
     "execution_count": 637,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results_df.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dfb2f0f-3962-4473-a897-696a1b3ed934",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}