predicting_motogp_winners\supervised_learning

supervised_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Predicting MotoGP Winners"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Supervised Learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "#pd.options.mode.chained_assignment = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading in the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_motogpsession = pd.read_csv('data/motogpsession.tsv', sep='\\t', encoding='utf-8')\n",
    "df_motogpqresult = pd.read_csv('data/motogpqresult.tsv', sep='\\t', encoding='utf-8')\n",
    "df_motogprresult = pd.read_csv('data/motogprresult.tsv', sep='\\t', encoding='utf-8')\n",
    "df_motogprider = pd.read_csv('data/motogprider.tsv', sep='\\t', encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_motogpsession = df_motogpsession.loc[:, ~df_motogpsession.columns.str.contains('^Unnamed')]\n",
    "df_motogpqresult = df_motogpqresult.loc[:, ~df_motogpqresult.columns.str.contains('^Unnamed')]\n",
    "df_motogprresult = df_motogprresult.loc[:, ~df_motogprresult.columns.str.contains('^Unnamed')]\n",
    "df_motogprider = df_motogprider.loc[:, ~df_motogprider.columns.str.contains('^Unnamed')]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_motogpdata = {}\n",
    "\n",
    "dict_motogpdata['session'] = df_motogpsession\n",
    "dict_motogpdata['qresult'] = df_motogpqresult\n",
    "dict_motogpdata['rresult'] = df_motogprresult\n",
    "dict_motogpdata['rider'] = df_motogprider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first need to generate our set of features and label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_labelfeat(dict_motodata):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    df_motosession = dict_motodata['session']\n",
    "    df_motoqresult = dict_motodata['qresult']\n",
    "    df_motorresult = dict_motodata['rresult']\n",
    "    df_motorider = dict_motodata['rider']\n",
    "\n",
    "    # Create dictonary for session id to session type\n",
    "    dict_sessionidsession = df_motosession.set_index('sessionId')['sessionSession'].to_dict()\n",
    "\n",
    "    # Create dictonary for session id to race session id\n",
    "    dict_sessionidracsessionid = {}\n",
    "    for index, row in df_motosession.iterrows():\n",
    "        sessionid = row['sessionId']\n",
    "        sessionseason = row['sessionSeason']\n",
    "        sessioncountry = row['sessionCountry']\n",
    "\n",
    "        df_temp1 = df_motosession[(df_motosession['sessionSeason'] == sessionseason) & \\\n",
    "                                  (df_motosession['sessionCountry'] == sessioncountry) & \\\n",
    "                                  (df_motosession['sessionSession'] == 'RAC2')]\n",
    "\n",
    "        df_temp2 = df_motosession[(df_motosession['sessionSeason'] == sessionseason) & \\\n",
    "                                  (df_motosession['sessionCountry'] == sessioncountry) & \\\n",
    "                                  (df_motosession['sessionSession'] == 'RAC')]\n",
    "\n",
    "        if len(df_temp1) > 0:\n",
    "            dict_sessionidracsessionid[sessionid] = df_temp1['sessionId'].values[0]\n",
    "\n",
    "        elif len(df_temp2) > 0:\n",
    "            dict_sessionidracsessionid[sessionid] = df_temp2['sessionId'].values[0]\n",
    "\n",
    "        else:\n",
    "            # print(sessionid, sessionseason, sessioncountry)\n",
    "            dict_sessionidracsessionid[sessionid] = np.nan\n",
    "\n",
    "    # Copy qualifying result dataframe\n",
    "    df_temp = df_motoqresult.copy()\n",
    "\n",
    "    # Add session type to qresults\n",
    "    df_temp['sessionId2'] = df_temp['sessionId']\n",
    "    df_temp['sessionId2'] = df_temp['sessionId2'].replace(dict_sessionidsession)\n",
    "    df_temp = df_temp.rename(columns={'sessionId2': 'sessionSession'})\n",
    "\n",
    "    # Add race session id\n",
    "    df_temp['sessionId3'] = df_temp['sessionId']\n",
    "    df_temp['sessionId3'] = df_temp['sessionId3'].replace(dict_sessionidracsessionid)\n",
    "    df_temp = df_temp.rename(columns={'sessionId3': 'racsessionId'})\n",
    "\n",
    "    # Drop records which are missing race session id\n",
    "    df_temp = df_temp.dropna(subset=['racsessionId'])\n",
    "\n",
    "    # Crete new race session id + rider id index\n",
    "    df_temp['racsessionriderId'] = df_temp['racsessionId'].map(str) + '_' + df_temp['riderId'].map(str)\n",
    "    df_temp = df_temp.drop(['sessionId', 'riderId', 'racsessionId'], 1)\n",
    "\n",
    "    # Pivot table on new index and to new fields as needed\n",
    "    df_temp = df_temp.pivot(index='racsessionriderId', columns='sessionSession')\n",
    "    df_temp.columns = [str(x) + str(y) for x, y in list(df_temp.columns)]\n",
    "    df_temp = df_temp.reset_index()\n",
    "    df_ids = df_temp.racsessionriderId.str.split('_').apply(pd.Series)\n",
    "    df_ids.columns = ['racsessionId', 'riderId']\n",
    "    df_temp = pd.concat([df_temp, df_ids], axis=1)\n",
    "\n",
    "    # Drop race session id + rider id index\n",
    "    df_temp = df_temp.drop('racsessionriderId', 1)\n",
    "    df_temp = df_temp.rename(columns={'racsessionId': 'sessionId'})\n",
    "    df_temp[['sessionId', 'riderId']] = df_temp[['sessionId', 'riderId']].astype(float)\n",
    "\n",
    "    # Merge race result, rider and session data\n",
    "    df_temp = pd.merge(df_temp, df_motorresult, on=['riderId', 'sessionId'], how='left')\n",
    "    df_temp = pd.merge(df_temp, df_motorider, on='riderId', how='left')\n",
    "    df_temp = pd.merge(df_temp, df_motosession, on='sessionId', how='left')\n",
    "\n",
    "    df_index = df_temp[['sessionId', 'sessionSeason', 'sessionCountry', 'riderId', 'riderName']].copy()\n",
    "\n",
    "    # Extract sessionId\n",
    "    list_sessionId = df_temp['sessionId']\n",
    "\n",
    "    # Drop unnecessary and non-feature fields\n",
    "    df_temp = df_temp.drop(['riderId',\n",
    "                            # 'riderName',\n",
    "                            'riderNumber',\n",
    "                            'rresultTotaltime',\n",
    "                            'rresultAvgspeed',\n",
    "                            'sessionId',\n",
    "                            'sessionSeason',\n",
    "                            'sessionClass',\n",
    "                            'sessionCountry',\n",
    "                            'sessionSession',\n",
    "                            'sessionDate'], 1)\n",
    "\n",
    "    # Insert sessionId back as first column in features dataframe\n",
    "    df_temp.insert(0, 'sessionId', list_sessionId)\n",
    "\n",
    "    # Convert race result field to 0/1\n",
    "    df_temp['rresultPlace'][df_temp['rresultPlace'] > 1] = 0\n",
    "    df_temp['rresultPlace'] = df_temp['rresultPlace'].fillna(0)\n",
    "\n",
    "    # Extract label and features dataframe\n",
    "    df_label = df_temp[['rresultPlace']]\n",
    "    df_features = df_temp.drop('rresultPlace', 1)\n",
    "\n",
    "    return df_label, df_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\ipykernel_launcher.py:97: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n"
     ]
    }
   ],
   "source": [
    "df_motogplabel, df_motogpfeatures = generate_labelfeat(dict_motogpdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "71\n"
     ]
    }
   ],
   "source": [
    "print(len(df_motogpfeatures.columns))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convertdatetime(dt):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    import re\n",
    "    import numpy as np\n",
    "\n",
    "    from datetime import datetime\n",
    "\n",
    "    dt = str(dt)\n",
    "\n",
    "    if dt == 'None':\n",
    "        return np.NaN\n",
    "\n",
    "    else:\n",
    "        f = '\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}.\\d{6}'\n",
    "        r = re.compile(f)\n",
    "        if r.match(dt) is None:\n",
    "            dt = dt + '.000000'\n",
    "\n",
    "        try:\n",
    "            f = '%Y-%m-%d %H:%M:%S.%f'\n",
    "            a = datetime.strptime(dt, f)\n",
    "            b = datetime(1900, 1, 1)\n",
    "        except:\n",
    "            return np.NaN\n",
    "\n",
    "        return (a - b).total_seconds()\n",
    "\n",
    "    \n",
    "def preprocess_features(df_in):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    import pandas as pd\n",
    "\n",
    "    list_ignorecolumns = ['sessionId']\n",
    "\n",
    "    list_timecolumns = ['qresultBesttimeFP',\n",
    "                        'qresultBesttimeFP1',\n",
    "                        'qresultBesttimeFP2',\n",
    "                        'qresultBesttimeFP3',\n",
    "                        'qresultBesttimeFP4',\n",
    "                        'qresultBesttimeQP',\n",
    "                        'qresultBesttimeQP1',\n",
    "                        'qresultBesttimeQP2',\n",
    "                        'qresultBesttimeQ1',\n",
    "                        'qresultBesttimeQ2',\n",
    "                        'qresultBesttimeWUP',\n",
    "                        'qresultBesttimeWUP2']\n",
    "\n",
    "    df_out = pd.DataFrame(index=df_in.index)\n",
    "    for col_name, col_values in df_in.iteritems():\n",
    "        if col_name in list_ignorecolumns:\n",
    "            col_values = col_values\n",
    "\n",
    "        elif col_name in list_timecolumns:\n",
    "            col_values = col_values.astype(str)\n",
    "            col_values = col_values.apply(convertdatetime)\n",
    "\n",
    "        elif col_values.dtype == object:\n",
    "            col_values = col_values.replace(['yes', 'no'], [1, 0])\n",
    "            col_values = pd.get_dummies(col_values, prefix=col_name)\n",
    "        df_out = df_out.join(col_values)\n",
    "\n",
    "        df_out = df_out.fillna(0)\n",
    "\n",
    "    return df_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_motogpallfeatures = preprocess_features(df_motogpfeatures)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate kbest feature scores and plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_kbestscores(df_label, df_features, k):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    from sklearn.feature_selection import SelectKBest\n",
    "    from sklearn.feature_selection import f_classif\n",
    "\n",
    "    list_features = df_features.columns\n",
    "\n",
    "    kbsel = SelectKBest(k=k, score_func=f_classif).fit(df_features, df_label['rresultPlace'].values)\n",
    "\n",
    "    # Create tables for the K-best features Anova F-value.\n",
    "    df_kbfeat = pd.DataFrame([list_features, kbsel.scores_]).T\n",
    "    df_kbfeat.columns = ['Feature', 'Anova F-value']\n",
    "    df_kbfeat = df_kbfeat.sort_values(['Anova F-value'], ascending=False).reset_index(drop=True)\n",
    "\n",
    "    return df_kbfeat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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>Feature</th>\n",
       "      <th>Anova F-value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>qresultPlaceFP2</td>\n",
       "      <td>334.354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>qresultPlaceWUP</td>\n",
       "      <td>328.166</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>qresultPlaceFP1</td>\n",
       "      <td>304.539</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>riderName_Casey STONER</td>\n",
       "      <td>266.57</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>riderName_Marc MARQUEZ</td>\n",
       "      <td>248.286</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>400</th>\n",
       "      <td>sessionTrackname_Sachsenring</td>\n",
       "      <td>4.53492e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>401</th>\n",
       "      <td>sessionTrackname_Autodromo del Mugello</td>\n",
       "      <td>4.53492e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>402</th>\n",
       "      <td>sessionTrackname_Losail International Circuit</td>\n",
       "      <td>4.31584e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>403</th>\n",
       "      <td>riderTeam_Red Bull Yamaha WCM</td>\n",
       "      <td>1.13509e-05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>404</th>\n",
       "      <td>sessionTrackname_Nelson Piquet Circuit</td>\n",
       "      <td>7.5337e-06</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>405 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                                           Feature Anova F-value\n",
       "0                                  qresultPlaceFP2       334.354\n",
       "1                                  qresultPlaceWUP       328.166\n",
       "2                                  qresultPlaceFP1       304.539\n",
       "3                           riderName_Casey STONER        266.57\n",
       "4                           riderName_Marc MARQUEZ       248.286\n",
       "..                                             ...           ...\n",
       "400                   sessionTrackname_Sachsenring   4.53492e-05\n",
       "401         sessionTrackname_Autodromo del Mugello   4.53492e-05\n",
       "402  sessionTrackname_Losail International Circuit   4.31584e-05\n",
       "403                  riderTeam_Red Bull Yamaha WCM   1.13509e-05\n",
       "404         sessionTrackname_Nelson Piquet Circuit    7.5337e-06\n",
       "\n",
       "[405 rows x 2 columns]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_kbfeatscoresmotogp = generate_kbestscores(df_motogplabel, df_motogpallfeatures, 'all')\n",
    "\n",
    "df_kbfeatscoresmotogp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_kbestfeatplot(df_kbfeat):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    plt.clf()\n",
    "\n",
    "    fig = plt.figure(figsize=(16, 6))\n",
    "\n",
    "    ax = sns.barplot(x='Feature',\n",
    "                     y='Anova F-value',\n",
    "                     data=df_kbfeat, color='c')\n",
    "\n",
    "    ax.set_xticklabels(ax.get_xticklabels(),\n",
    "                       rotation=45, ha='right')\n",
    "\n",
    "    ax.set_title('MotoGP 2007-17 - Variable Importance')\n",
    "    ax.set_ylabel('Anova F-value')\n",
    "\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = generate_kbestfeatplot(df_kbfeatscoresmotogp[:40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig('images/motogpkbest.png', bbox_inches='tight', pad_inches=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create the final feature dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_motogpkbestfeatures = ['sessionId',\n",
    "                          'qresultPlaceFP',\n",
    "                          'qresultPlaceFP1',\n",
    "                          'qresultPlaceFP2',\n",
    "                          'qresultPlaceFP3',\n",
    "                          'qresultPlaceFP4',\n",
    "                          'qresultPlaceQ1',\n",
    "                          'qresultPlaceQ2',\n",
    "                          'qresultPlaceQP',\n",
    "                          'qresultPlaceQP1',\n",
    "                          'qresultPlaceQP2',\n",
    "                          'qresultPlaceWUP',\n",
    "                          'qresultBestlapFP',\n",
    "                          'qresultBestlapFP1',\n",
    "                          'qresultBestlapFP2',\n",
    "                          'qresultBestlapFP3',\n",
    "                          'qresultBestlapFP4',\n",
    "                          'qresultBestlapQ1',\n",
    "                          'qresultBestlapQ2',\n",
    "                          'qresultBestlapQP',\n",
    "                          'qresultBestlapQP1',\n",
    "                          'qresultBestlapQP2',\n",
    "                          'qresultBestlapWUP',\n",
    "                          'qresultTopspeedFP',\n",
    "                          'qresultTopspeedFP1',\n",
    "                          'qresultTopspeedFP2',\n",
    "                          'qresultTopspeedFP3',\n",
    "                          'qresultTopspeedFP4',\n",
    "                          'qresultTopspeedQ1',\n",
    "                          'qresultTopspeedQ2',\n",
    "                          'qresultTopspeedQP',\n",
    "                          'qresultTopspeedQP1',\n",
    "                          'qresultTopspeedQP2',\n",
    "                          'qresultTopspeedWUP',\n",
    "                          'qresultTotallapFP',\n",
    "                          'qresultTotallapFP1',\n",
    "                          'qresultTotallapFP2',\n",
    "                          'qresultTotallapFP3',\n",
    "                          'qresultTotallapFP4',\n",
    "                          'qresultTotallapQ1',\n",
    "                          'qresultTotallapQ2',\n",
    "                          'qresultTotallapQP',\n",
    "                          'qresultTotallapQP1',\n",
    "                          'qresultTotallapQP2',\n",
    "                          'qresultTotallapWUP',\n",
    "                          'qresultBesttimeFP',\n",
    "                          'qresultBesttimeFP1',\n",
    "                          'qresultBesttimeFP2',\n",
    "                          'qresultBesttimeFP3',\n",
    "                          'qresultBesttimeFP4',\n",
    "                          'qresultBesttimeQ1',\n",
    "                          'qresultBesttimeQ2',\n",
    "                          'qresultBesttimeQP',\n",
    "                          'qresultBesttimeQP1',\n",
    "                          'qresultBesttimeQP2',\n",
    "                          'qresultBesttimeWUP']\n",
    "\n",
    "df_motogpkbestfeatures = df_motogpallfeatures[list_motogpkbestfeatures]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create some helpers for our supervised learning routines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shuffle_split_data(y_true_all, X_all, test_size):\n",
    "    \"\"\"  \"\"\"\n",
    "\n",
    "    from sklearn.model_selection import train_test_split\n",
    "\n",
    "    X_train, X_test, y_true_train, y_true_test = train_test_split(X_all, y_true_all, test_size=test_size)\n",
    "\n",
    "    return X_train, y_true_train, X_test, y_true_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_clf(clf, X, y_true, metric):\n",
    "    \"\"\"  \"\"\"\n",
    "\n",
    "    y_pred = clf.predict_proba(X[:, 1:])\n",
    "    y_pred = convert_pred(X[:, 0], y_pred[:, 1])\n",
    "\n",
    "    score = performance_metric(y_true, y_pred, metric)\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_pred(sessionId, y_pred_orig):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    import pandas as pd\n",
    "\n",
    "    df_temp = pd.DataFrame({'sessionId': sessionId, 'y_pred_orig': y_pred_orig})\n",
    "\n",
    "    df_temp['y_pred_adj'] = 0\n",
    "\n",
    "    for s in df_temp['sessionId'].unique():\n",
    "        max_prob = df_temp[df_temp['sessionId'] == s]['y_pred_orig'].max()\n",
    "        if max_prob >= 0.5:\n",
    "            df_temp.loc[(df_temp['sessionId'] == s) & (df_temp['y_pred_orig'] == max_prob), 'y_pred_adj'] = 1\n",
    "\n",
    "    y_pred_adj = df_temp['y_pred_adj'].values\n",
    "\n",
    "    return y_pred_adj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_metric(y_true, y_pred, metric):\n",
    "    \"\"\"  \"\"\"\n",
    "\n",
    "    from sklearn.metrics import accuracy_score\n",
    "    from sklearn.metrics import f1_score\n",
    "    from sklearn.metrics import recall_score\n",
    "    from sklearn.metrics import precision_score\n",
    "\n",
    "    if metric == 'accuracy':\n",
    "        score = accuracy_score(y_true, y_pred)\n",
    "    elif metric == 'f1':\n",
    "        score = f1_score(y_true, y_pred)\n",
    "    elif metric == 'recall':\n",
    "        score = recall_score(y_true, y_pred)\n",
    "    elif metric == 'precision':\n",
    "        score = precision_score(y_true, y_pred)\n",
    "\n",
    "    return score"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate learning curve plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_learningcurves(y_true_all, X_all, metric):\n",
    "    \"\"\" \"\"\"\n",
    "\n",
    "    np.random.seed(0)\n",
    "\n",
    "    plt.clf()\n",
    "\n",
    "    fig = plt.figure(figsize=(18, 10))\n",
    "\n",
    "    training_sizes = np.round(np.linspace(0.1, 0.9, 5), 10)\n",
    "\n",
    "    # DT -------------------------------\n",
    "\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    for s in training_sizes:\n",
    "        for i in range(0, 5):\n",
    "            X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 1 - s)\n",
    "\n",
    "            clf = DecisionTreeClassifier()\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [s, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [s, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 1)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Decision Tree')\n",
    "    ax.set_xlabel('Training Set Size (%)')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    # DT w Boost -------------------------------\n",
    "\n",
    "    from sklearn.ensemble import AdaBoostClassifier\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    for s in training_sizes:\n",
    "        for i in range(0, 5):\n",
    "            X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 1 - s)\n",
    "\n",
    "            clf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier())\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [s, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [s, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 2)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Decision Tree w Boosting')\n",
    "    ax.set_xlabel('Training Set Size (%)')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    # SVC -------------------------------\n",
    "\n",
    "    from sklearn.svm import SVC, LinearSVC\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    for s in training_sizes:\n",
    "        for i in range(0, 5):\n",
    "            X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 1 - s)\n",
    "\n",
    "            clf = SVC(probability=True)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [s, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [s, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 3)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Support Vector Machine')\n",
    "    ax.set_xlabel('Training Set Size (%)')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    # kNN -------------------------------\n",
    "\n",
    "    from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    for s in training_sizes:\n",
    "        for i in range(0, 5):\n",
    "            X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 1 - s)\n",
    "\n",
    "            clf = KNeighborsClassifier()\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [s, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [s, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 4)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('k-Nearest Neighbors')\n",
    "    ax.set_xlabel('Training Set Size (%)')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    # MLP -------------------------------\n",
    "\n",
    "    from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    for s in training_sizes:\n",
    "        for i in range(0, 5):\n",
    "            X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 1 - s)\n",
    "\n",
    "            clf = MLPClassifier()\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [s, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [s, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 5)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Neural Network')\n",
    "    ax.set_xlabel('Training Set Size (%)')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x720 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#X_all = df_motogpallfeatures.values\n",
    "X_all = df_motogpkbestfeatures.values\n",
    "#X_all = df_motogpnoidfeatures.values\n",
    "\n",
    "y_true_all = df_motogplabel['rresultPlace'].values\n",
    "\n",
    "fig = generate_learningcurves(y_true_all, X_all, 'f1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig('images/motogplc.png', bbox_inches='tight', pad_inches=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generate complexity plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_complexitycurves(y_true_all, X_all, metric):\n",
    "    \"\"\"  \"\"\"\n",
    "\n",
    "    np.random.seed(0)\n",
    "\n",
    "    X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 0.3)\n",
    "\n",
    "    plt.clf()\n",
    "\n",
    "    fig = plt.figure(figsize=(18, 10))\n",
    "\n",
    "    # DT -------------------------------\n",
    "\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    max_depth = np.linspace(1, 20, 10, dtype=int)\n",
    "\n",
    "    for p in max_depth:\n",
    "        for i in range(0, 5):\n",
    "            clf = DecisionTreeClassifier(max_depth=p)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [p, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [p, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 1)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Decision Tree')\n",
    "    ax.set_xlabel('max_depth')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([1, 15])\n",
    "\n",
    "    # DT w Boost -------------------------------\n",
    "\n",
    "    from sklearn.ensemble import AdaBoostClassifier\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    n_estimators = np.linspace(10, 100, 10, dtype=int)\n",
    "\n",
    "    for p in n_estimators:\n",
    "        for i in range(0, 5):\n",
    "            clf = AdaBoostClassifier(base_estimator=DecisionTreeClassifier(max_depth=3), n_estimators=p)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [p, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [p, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 2)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Decision Tree w Boosting')\n",
    "    ax.set_xlabel('n_estimators')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    # ax.set_xlim([10, 100])\n",
    "\n",
    "    # SVC -------------------------------\n",
    "\n",
    "    from sklearn.svm import SVC, LinearSVC\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    # gamma = np.linspace(0.0001, 1, 10)\n",
    "    gamma = np.round(np.linspace(0.0001, 0.01, 10), 10)\n",
    "    # maxit = np.linspace(1000, 10000, 10, dtype=int)\n",
    "\n",
    "    for p in gamma:\n",
    "        # for m in maxit:\n",
    "        for i in range(0, 5):\n",
    "            # clf = SVC(probability=True, gamma=p)\n",
    "            clf = SVC(probability=True, gamma=p)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [p, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [p, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 3)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Support Vector Machine')\n",
    "    ax.set_xlabel('gamma')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    ax.set_xticklabels(ax.get_xticklabels(), rotation=30)\n",
    "    # ax.set_xlim([0.0001, 0.001])\n",
    "\n",
    "    # kNN -------------------------------\n",
    "\n",
    "    from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    neighbors = np.linspace(1, 5, 5, dtype=int)\n",
    "\n",
    "    for p in neighbors:\n",
    "        for i in range(0, 5):\n",
    "            clf = KNeighborsClassifier(n_neighbors=p)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [p, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [p, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 4)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('k-Nearest Neighbors')\n",
    "    ax.set_xlabel('neighbors')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    ax.invert_xaxis()\n",
    "    # ax.set_xlim([1, 5])\n",
    "\n",
    "    # MLP -------------------------------\n",
    "\n",
    "    from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "    df_temp = pd.DataFrame(columns=['s', 'score', 'set'])\n",
    "\n",
    "    alpha = [0.000001, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]\n",
    "\n",
    "    for p in alpha:\n",
    "        for i in range(0, 5):\n",
    "            clf = MLPClassifier(alpha=p)\n",
    "            clf = clf.fit(X_train[:, 1:], y_true_train)\n",
    "\n",
    "            train_s = eval_clf(clf, X_train, y_true_train, metric)\n",
    "            test_s = eval_clf(clf, X_test, y_true_test, metric)\n",
    "\n",
    "            df_temp.loc[len(df_temp.index)] = [p, test_s, 'test']\n",
    "            df_temp.loc[len(df_temp.index)] = [p, train_s, 'train']\n",
    "\n",
    "    ax = fig.add_subplot(2, 3, 5)\n",
    "\n",
    "    ax = sns.pointplot(x='s', y='score', hue='set', data=df_temp)\n",
    "\n",
    "    ax.legend()\n",
    "    ax.set_title('Neural Network')\n",
    "    ax.set_xlabel('alpha')\n",
    "    ax.set_ylabel(metric + ' Score')\n",
    "    ax.set_xticklabels(ax.get_xticklabels(), rotation=30)\n",
    "    ax.invert_xaxis()\n",
    "    # ax.set_xlim([1, 5])\n",
    "\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n",
      "C:\\Users\\buswedg\\Anaconda3\\envs\\Python37\\lib\\site-packages\\sklearn\\neural_network\\_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n",
      "  % self.max_iter, ConvergenceWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x720 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#X_all = df_motogpallfeatures.values\n",
    "X_all = df_motogpkbestfeatures.values\n",
    "#X_all = df_motogpnoidfeatures.values\n",
    "\n",
    "y_true_all = df_motogplabel['rresultPlace'].values\n",
    "\n",
    "fig = generate_complexitycurves(y_true_all, X_all, 'f1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig.savefig('images/motogpcc.png', bbox_inches='tight', pad_inches=0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perform gridsearch cross validation optimization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_clf_list(clf_select):\n",
    "    list_ref = []\n",
    "    list_clf = []\n",
    "    list_param = []\n",
    "\n",
    "    if 1 in clf_select:\n",
    "        ref = 'mmscale'\n",
    "        clf = 'MinMaxScaler()'\n",
    "        dict_param = {}\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 2 in clf_select:\n",
    "        ref = 'stdscale'\n",
    "        clf = 'StandardScaler()'\n",
    "        dict_param = {}\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 3 in clf_select:\n",
    "        ref = 'skb'\n",
    "        clf = 'SelectKBest()'\n",
    "        dict_param = {'k': [2, 4, 6, 8, 10, 12, 14, 16, 'all']}\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 4 in clf_select:\n",
    "        ref = 'naive'\n",
    "        clf = 'GaussianNB()'\n",
    "        dict_param = {}\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 5 in clf_select:\n",
    "        # http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html\n",
    "        ref = 'dt'\n",
    "        clf = 'DecisionTreeClassifier()'\n",
    "        dict_param = {'criterion': ['gini', 'entropy'],  # default='gini'\n",
    "                      'splitter': ['random', 'best'],  # default='best'\n",
    "                      'max_depth': [1, 2, 3, 4, 5, 6, 7],  # default=None\n",
    "                      'max_features': ['auto', None]}  # default=None\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 6 in clf_select:\n",
    "        # http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html\n",
    "        ref = 'dtb'\n",
    "        clf = 'AdaBoostClassifier(DecisionTreeClassifier())'\n",
    "        dict_param = {'base_estimator__max_depth': [1, 2, 3, 4, 5, 6, 7],  # default=None\n",
    "                      'n_estimators': [10, 15, 20, 25, 30, 35, 40],  # default=50\n",
    "                      'learning_rate': [0.001, 0.01, 0.1, 1.0]}  # default=1.\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 7 in clf_select:\n",
    "        # http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html\n",
    "        ref = 'linsvc'\n",
    "        clf = 'SVC()'\n",
    "        # 'kernel': ['rbf', 'linear', 'poly'], # default='rbf'\n",
    "        dict_param = {'kernel': ['rbf'],  # default='rbf'\n",
    "                      'C': [0.001, 0.01, 0.1, 1.0],  # default=1.0\n",
    "                      'gamma': [0.0001, 0.001, 0.01, 0.1, 'auto'],  # default='auto'\n",
    "                      'tol': [0.00001, 0.0001, 0.001],  # default=1e-3\n",
    "                      'probability': [True]}  # default=False\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 8 in clf_select:\n",
    "        # http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html\n",
    "        ref = 'knn'\n",
    "        clf = 'KNeighborsClassifier()'\n",
    "        dict_param = {'n_neighbors': [2, 3, 4, 5, 6],  # default = 5\n",
    "                      'leaf_size': [10, 20, 30, 40, 50],  # default = 30\n",
    "                      'n_jobs': [-1]}  # default = 1\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    if 9 in clf_select:\n",
    "        # http://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html\n",
    "        ref = 'mlp'\n",
    "        clf = 'MLPClassifier()'\n",
    "        dict_param = {'solver': ['lbfgs', 'sgd', 'adam'],  # default 'adam'\n",
    "                      'alpha': [0.00001, 0.0001, 0.001, 0.01, 0.1],  # default 0.0001\n",
    "                      'tol': [0.000001, 0.00001, 0.0001, 0.001]}  # default=1e-4\n",
    "        list_ref.append((ref))\n",
    "        list_clf.append((clf))\n",
    "        list_param.append((dict_param))\n",
    "\n",
    "    return list_ref, list_clf, list_param"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_clf_list(list_clf, X, y_true, metric):\n",
    "    list_clfscore = []\n",
    "\n",
    "    for clf in list_clf:\n",
    "        score = eval_clf(clf, X, y_true, 'f1')\n",
    "        list_clfscore.append((score))\n",
    "\n",
    "    return list_clfscore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_pipe(ref, clf, dict_param):\n",
    "    from sklearn.preprocessing import MinMaxScaler\n",
    "    from sklearn.preprocessing import StandardScaler\n",
    "    from sklearn.feature_selection import SelectKBest\n",
    "    from sklearn.naive_bayes import GaussianNB\n",
    "    from sklearn.tree import DecisionTreeClassifier\n",
    "    from sklearn.ensemble import AdaBoostClassifier\n",
    "    from sklearn.svm import SVC, LinearSVC\n",
    "    from sklearn.neighbors import KNeighborsClassifier\n",
    "    from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "    list_piperef = []\n",
    "    dict_pipeparam = {}\n",
    "\n",
    "    list_piperef.append((ref, eval(clf)))\n",
    "\n",
    "    for key, value in dict_param.items():\n",
    "        dict_pipeparam[ref + \"__\" + key] = value\n",
    "\n",
    "    return list_piperef, dict_pipeparam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_pipe_list(list_ref, list_clf, list_param):\n",
    "    import itertools\n",
    "\n",
    "    list_piperefs = []\n",
    "    dict_pipeparams = {}\n",
    "\n",
    "    for ref, clf, dict_param in zip(list_ref, list_clf, list_param):\n",
    "        list_piperef, dict_pipeparam = build_pipe(ref, clf, dict_param)\n",
    "\n",
    "        list_piperefs.append((list_piperef[0][0], list_piperef[0][1]))\n",
    "        dict_pipeparams.update(dict_pipeparam)\n",
    "\n",
    "    return list_piperefs, dict_pipeparams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def execute_pipe(clf_select, X_all, X_test, y_true_all, y_true_test):\n",
    "    \"\" \"\"\n",
    "\n",
    "    import timeit\n",
    "\n",
    "    from sklearn.pipeline import Pipeline\n",
    "    #from sklearn.model_selection import StratifiedShuffleSplit\n",
    "    from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "    start = timeit.default_timer()\n",
    "\n",
    "    list_ref, list_clf, list_param = build_clf_list(clf_select)\n",
    "    list_piperefs, dict_pipeparams = build_pipe_list(list_ref, list_clf, list_param)\n",
    "\n",
    "    pipe = Pipeline(list_piperefs)\n",
    "    #cv = StratifiedShuffleSplit(y_true_all, test_size=0.3)\n",
    "    \n",
    "    np.random.seed(0)\n",
    "\n",
    "    grid_search = GridSearchCV(pipe, dict_pipeparams, n_jobs=1, scoring='f1')\n",
    "    \n",
    "    grid_search.fit(X_all[:, 1:], y_true_all)\n",
    "\n",
    "    stop = timeit.default_timer()\n",
    "\n",
    "    time = (stop - start) / 60\n",
    "\n",
    "    clf_best = grid_search.best_estimator_\n",
    "    # print(clf_best)\n",
    "\n",
    "    param_best = grid_search.best_params_\n",
    "    # print(param_best)\n",
    "\n",
    "    score_best = grid_search.best_score_\n",
    "    # print(score_best)\n",
    "\n",
    "    f1score = eval_clf(clf_best, X_test, y_true_test, 'f1')\n",
    "    recall = eval_clf(clf_best, X_test, y_true_test, 'recall')\n",
    "    precision = eval_clf(clf_best, X_test, y_true_test, 'precision')\n",
    "    # print(\"Recall:\", recall, \"Precision:\", precision, \"F1 Score:\", f1score)\n",
    "\n",
    "    # list_results = [list_clf[0], param_best, f1score, recall, precision, time]\n",
    "    list_results = [list_clf, param_best, f1score, recall, precision, time]\n",
    "\n",
    "    return list_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#X_all = df_motogpallfeatures.values\n",
    "X_all = df_motogpkbestfeatures.values\n",
    "#X_all = df_motogpnoidfeatures.values\n",
    "\n",
    "y_true_all = df_motogplabel['rresultPlace'].values\n",
    "\n",
    "X_train, y_true_train, X_test, y_true_test = shuffle_split_data(y_true_all, X_all, 0.25)\n",
    "\n",
    "clf_select = [[5], [6], [7], [8], [9]]\n",
    "\n",
    "df_motogpresults = pd.DataFrame(columns=['clf', 'param', 'f1', 'recall', 'precision', 'time'])\n",
    "\n",
    "for c in clf_select:\n",
    "    list_results = execute_pipe(c, X_all, X_test, y_true_all, y_true_test)\n",
    "    df_motogpresults.loc[len(df_motogpresults.index)] = list_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "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>clf</th>\n",
       "      <th>param</th>\n",
       "      <th>f1</th>\n",
       "      <th>recall</th>\n",
       "      <th>precision</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>[DecisionTreeClassifier()]</td>\n",
       "      <td>{'dt__criterion': 'gini', 'dt__max_depth': 6, ...</td>\n",
       "      <td>0.225806</td>\n",
       "      <td>0.132075</td>\n",
       "      <td>0.777778</td>\n",
       "      <td>0.046610</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>[AdaBoostClassifier(DecisionTreeClassifier())]</td>\n",
       "      <td>{'dtb__base_estimator__max_depth': 1, 'dtb__le...</td>\n",
       "      <td>0.423529</td>\n",
       "      <td>0.339623</td>\n",
       "      <td>0.562500</td>\n",
       "      <td>8.677857</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>[SVC()]</td>\n",
       "      <td>{'linsvc__C': 0.001, 'linsvc__gamma': 0.0001, ...</td>\n",
       "      <td>0.037037</td>\n",
       "      <td>0.018868</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>23.621196</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>[KNeighborsClassifier()]</td>\n",
       "      <td>{'knn__leaf_size': 10, 'knn__n_jobs': -1, 'knn...</td>\n",
       "      <td>0.107143</td>\n",
       "      <td>0.056604</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.198638</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>[MLPClassifier()]</td>\n",
       "      <td>{'mlp__alpha': 1e-05, 'mlp__solver': 'adam', '...</td>\n",
       "      <td>0.125000</td>\n",
       "      <td>0.075472</td>\n",
       "      <td>0.363636</td>\n",
       "      <td>3.741494</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                              clf  \\\n",
       "0                      [DecisionTreeClassifier()]   \n",
       "1  [AdaBoostClassifier(DecisionTreeClassifier())]   \n",
       "2                                         [SVC()]   \n",
       "3                        [KNeighborsClassifier()]   \n",
       "4                               [MLPClassifier()]   \n",
       "\n",
       "                                               param        f1    recall  \\\n",
       "0  {'dt__criterion': 'gini', 'dt__max_depth': 6, ...  0.225806  0.132075   \n",
       "1  {'dtb__base_estimator__max_depth': 1, 'dtb__le...  0.423529  0.339623   \n",
       "2  {'linsvc__C': 0.001, 'linsvc__gamma': 0.0001, ...  0.037037  0.018868   \n",
       "3  {'knn__leaf_size': 10, 'knn__n_jobs': -1, 'knn...  0.107143  0.056604   \n",
       "4  {'mlp__alpha': 1e-05, 'mlp__solver': 'adam', '...  0.125000  0.075472   \n",
       "\n",
       "   precision       time  \n",
       "0   0.777778   0.046610  \n",
       "1   0.562500   8.677857  \n",
       "2   1.000000  23.621196  \n",
       "3   1.000000   0.198638  \n",
       "4   0.363636   3.741494  "
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_motogpresults"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finish off with some benchmarking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def benchmark(dict_motodata):\n",
    "    \"\"\n",
    "\n",
    "    tp = 0\n",
    "    fp = 0\n",
    "    fn = 0\n",
    "\n",
    "    df_motorresult = dict_motodata['rresult']\n",
    "\n",
    "    list_motorresultsessid = df_motorresult[\"sessionId\"].unique()\n",
    "\n",
    "    for i in range(1, len(list_motorresultsessid), 1):\n",
    "        currsessionId = list_motorresultsessid[i]\n",
    "        prevsessionId = list_motorresultsessid[i-1]\n",
    "\n",
    "        pred = df_motorresult[(df_motorresult['sessionId'] == prevsessionId) & \\\n",
    "                              (df_motorresult['rresultPlace'] == 1)]['riderId'].iloc[0]\n",
    "        \n",
    "        win = df_motorresult[(df_motorresult['sessionId'] == currsessionId) & \\\n",
    "                             (df_motorresult['rresultPlace'] == 1)]['riderId'].iloc[0]\n",
    "        \n",
    "        if win == pred:\n",
    "            tp += 1\n",
    "        else:\n",
    "            fp += 1\n",
    "            fn += 1\n",
    "            \n",
    "    recall = float(tp) / (tp+fn)\n",
    "    precision = float(tp) / (tp+fp)\n",
    "    f1score = 2 * (precision * recall) / (precision + recall)\n",
    "    \n",
    "    return recall, precision, f1score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 Score: 0.3146551724137931\n"
     ]
    }
   ],
   "source": [
    "recall, precision, f1score = benchmark(dict_motogpdata)\n",
    "\n",
    "print(\"F1 Score:\", f1score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}