notebooks/modelling_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modelling Version 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Standard library imports\n",
    "from pathlib import Path\n",
    "import os\n",
    "import string\n",
    "from itertools import combinations\n",
    "\n",
    "# Third party imports\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "from scipy.stats import pointbiserialr, pearsonr\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV, RandomizedSearchCV\n",
    "from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression\n",
    "from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\n",
    "from sklearn.svm import SVR, SVC\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import (\n",
    "    mean_squared_error,\n",
    "    mean_absolute_error,\n",
    "    accuracy_score,\n",
    "    confusion_matrix,\n",
    "    classification_report,\n",
    "    make_scorer,\n",
    "    fbeta_score\n",
    ")\n",
    "from xgboost import XGBClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "sns.set_style('whitegrid')\n",
    "sns.set(font_scale=1.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read in data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = Path('../data')\n",
    "processed_prem_path = os.path.join(data_path, 'processed', 'processed_prem_fixtures_v2.csv')\n",
    "fixtures = pd.read_csv(processed_prem_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 7396 entries, 0 to 7395\n",
      "Data columns (total 33 columns):\n",
      " #   Column                              Non-Null Count  Dtype  \n",
      "---  ------                              --------------  -----  \n",
      " 0   match_id                            7396 non-null   int64  \n",
      " 1   date                                7396 non-null   object \n",
      " 2   season                              7396 non-null   int64  \n",
      " 3   team_id                             7396 non-null   int64  \n",
      " 4   team_name                           7396 non-null   object \n",
      " 5   opposition_id                       7396 non-null   int64  \n",
      " 6   opposition_name                     7396 non-null   object \n",
      " 7   scored                              7396 non-null   float64\n",
      " 8   conceded                            7396 non-null   float64\n",
      " 9   relative_score                      7396 non-null   float64\n",
      " 10  league_position                     7396 non-null   int64  \n",
      " 11  opposition_league_position          7396 non-null   int64  \n",
      " 12  HA_average_scored                   6996 non-null   float64\n",
      " 13  opposition_HA_average_scored        6996 non-null   float64\n",
      " 14  HA_average_conceded                 6996 non-null   float64\n",
      " 15  opposition_HA_average_conceded      6996 non-null   float64\n",
      " 16  HA_average_points                   6996 non-null   float64\n",
      " 17  opposition_HA_average_points        6996 non-null   float64\n",
      " 18  HA_form                             6996 non-null   float64\n",
      " 19  opposition_HA_form                  6996 non-null   float64\n",
      " 20  season_average_scored               7196 non-null   float64\n",
      " 21  opposition_season_average_scored    7196 non-null   float64\n",
      " 22  season_average_conceded             7196 non-null   float64\n",
      " 23  opposition_season_average_conceded  7196 non-null   float64\n",
      " 24  season_average_points               7196 non-null   float64\n",
      " 25  opposition_season_average_points    7196 non-null   float64\n",
      " 26  season_form                         7196 non-null   float64\n",
      " 27  opposition_season_form              7196 non-null   float64\n",
      " 28  games_played                        7396 non-null   float64\n",
      " 29  home                                7396 non-null   int64  \n",
      " 30  average_hth_points                  6360 non-null   float64\n",
      " 31  average_hth_relative_score          6360 non-null   float64\n",
      " 32  win                                 7396 non-null   float64\n",
      "dtypes: float64(23), int64(7), object(3)\n",
      "memory usage: 1.9+ MB\n"
     ]
    }
   ],
   "source": [
    "fixtures.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create features\n",
    "\n",
    "First, let's remove any fixtures where there is no head to head data available (as the teams haven't played before in the data I have collected)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixtures = fixtures[fixtures['average_hth_points'].notnull()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As many of the feautures are still reliant on gathering information from the season the fixture is played in I will remove the first 4 fixtures so the model has access to more accurate information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 5778 entries, 40 to 7395\n",
      "Data columns (total 33 columns):\n",
      " #   Column                              Non-Null Count  Dtype  \n",
      "---  ------                              --------------  -----  \n",
      " 0   match_id                            5778 non-null   int64  \n",
      " 1   date                                5778 non-null   object \n",
      " 2   season                              5778 non-null   int64  \n",
      " 3   team_id                             5778 non-null   int64  \n",
      " 4   team_name                           5778 non-null   object \n",
      " 5   opposition_id                       5778 non-null   int64  \n",
      " 6   opposition_name                     5778 non-null   object \n",
      " 7   scored                              5778 non-null   float64\n",
      " 8   conceded                            5778 non-null   float64\n",
      " 9   relative_score                      5778 non-null   float64\n",
      " 10  league_position                     5778 non-null   int64  \n",
      " 11  opposition_league_position          5778 non-null   int64  \n",
      " 12  HA_average_scored                   5778 non-null   float64\n",
      " 13  opposition_HA_average_scored        5778 non-null   float64\n",
      " 14  HA_average_conceded                 5778 non-null   float64\n",
      " 15  opposition_HA_average_conceded      5778 non-null   float64\n",
      " 16  HA_average_points                   5778 non-null   float64\n",
      " 17  opposition_HA_average_points        5778 non-null   float64\n",
      " 18  HA_form                             5778 non-null   float64\n",
      " 19  opposition_HA_form                  5778 non-null   float64\n",
      " 20  season_average_scored               5778 non-null   float64\n",
      " 21  opposition_season_average_scored    5778 non-null   float64\n",
      " 22  season_average_conceded             5778 non-null   float64\n",
      " 23  opposition_season_average_conceded  5778 non-null   float64\n",
      " 24  season_average_points               5778 non-null   float64\n",
      " 25  opposition_season_average_points    5778 non-null   float64\n",
      " 26  season_form                         5778 non-null   float64\n",
      " 27  opposition_season_form              5778 non-null   float64\n",
      " 28  games_played                        5778 non-null   float64\n",
      " 29  home                                5778 non-null   int64  \n",
      " 30  average_hth_points                  5778 non-null   float64\n",
      " 31  average_hth_relative_score          5778 non-null   float64\n",
      " 32  win                                 5778 non-null   float64\n",
      "dtypes: float64(23), int64(7), object(3)\n",
      "memory usage: 1.5+ MB\n"
     ]
    }
   ],
   "source": [
    "# Get rid of early season games\n",
    "fixtures = fixtures[fixtures['games_played'] > 3]\n",
    "fixtures.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, I want to calculate relative statistics between some of the features to find the difference between the teams."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_relative_statistic(fixtures, feature):\n",
    "    \"\"\"\n",
    "    Create relative statistics columns from features about each team in\n",
    "    fixture. Params:\n",
    "    - fixtures: pd.DataFrame\n",
    "    - feature: Statistic to calculate relative statistics from.\n",
    "    \"\"\"\n",
    "    # Get team and opposition stats\n",
    "    columns = {'team': feature, 'opposition': '_'.join(['opposition', feature])}\n",
    "    \n",
    "    # Reset index to avoid concat issue\n",
    "    new_fixtures = fixtures.reset_index(drop=True)\n",
    "    \n",
    "    # Calculate relative stat\n",
    "    relative_stat = fixtures[columns['team']] - fixtures[columns['opposition']]\n",
    "    relative_stat = relative_stat.rename('_'.join(['relative', feature]))\n",
    "\n",
    "    return pd.concat([fixtures, relative_stat], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "statistics = [\n",
    "    '_'.join([prefix, stat])\n",
    "    for prefix in ('HA', 'season')\n",
    "    for stat in ('average_scored', 'average_points', 'form', 'average_conceded')\n",
    "]\n",
    "statistics.append('league_position')\n",
    "for stat in statistics:\n",
    "    fixtures = get_relative_statistic(fixtures, stat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will create interaction terms to measure the interaction for different variables between the two teams. To do this I will create a function that will return the interaction terms between team and opposition and then calculate the relative stats of these.\n",
    "\n",
    "It doesn't make sense to calculate interaction terms from variables that can both be negative, as any occurances when both variables are negative multiplied together will make a positive. This will lose the meaning of the negative values indicating a worse result, so I won't calculate the interaction variables between statistics that can both take negative values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_interaction_terms(fixtures, features):\n",
    "    \"\"\"\n",
    "    Returns interaction terms between team and opposition statistics and returns the\n",
    "    relative of the interaction terms. Given the features inputed, creates interaction\n",
    "    terms between team and opposition features. If both features contain negative\n",
    "    results then these interaction terms are skipped.\n",
    "    \"\"\"\n",
    "    # Label each feature alphabetically\n",
    "    labeled_features = {string.ascii_uppercase[i]: feature for i, feature in enumerate(features)}\n",
    "    \n",
    "    interaction_terms = pd.DataFrame()\n",
    "    \n",
    "    # Loop through combinations of features\n",
    "    for a, b in combinations(labeled_features.keys(), 2):\n",
    "        \n",
    "        # Some stats are the same for team and opposition, this determines the columns\n",
    "        # needed for team and opposition\n",
    "        feat_a = [labeled_features[a], '_'.join(['opposition', labeled_features[a]])]\n",
    "        feat_a = feat_a if feat_a[1] in fixtures.columns else [feat_a[0]]*2\n",
    "        \n",
    "        feat_b = [labeled_features[b], '_'.join(['opposition', labeled_features[b]])]\n",
    "        feat_b = feat_b if feat_b[1] in fixtures.columns else [feat_b[0]]*2\n",
    "        \n",
    "        # Don't calculate interaction varibales from two variables with negatives \n",
    "        if any(fixtures[feat_a[0]] < 0) and any(fixtures[feat_b[0]] < 0):\n",
    "            continue\n",
    "        \n",
    "        # feat1 * opposition feat2\n",
    "        stat1 = fixtures[feat_a[0]] * fixtures[feat_b[1]]\n",
    "        \n",
    "        # feat2 * opposition feat1\n",
    "        stat2 = fixtures[feat_a[1]] * fixtures[feat_b[0]]\n",
    "        \n",
    "        # get relative of iteraction terms if stats calculated are different\n",
    "        stat = stat1 if all(stat1 == stat2) else stat1 - stat2\n",
    "        stat = stat.rename(f'{a}{b}')\n",
    "        \n",
    "        # Concat to all interaction terms\n",
    "        interaction_terms = pd.concat([interaction_terms, stat], axis=1)\n",
    "    \n",
    "    # Reset index to avoid concat issues\n",
    "    interaction_terms = interaction_terms.reset_index(drop=True)\n",
    "    \n",
    "    return pd.concat([fixtures.reset_index(drop=True), interaction_terms], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "interaction_features = [\n",
    "    'league_position', 'HA_average_scored', 'HA_average_conceded', 'HA_average_points',\n",
    "    'season_average_scored', 'season_average_conceded', 'season_average_points',\n",
    "    'average_hth_points', 'average_hth_relative_score',\n",
    "    'HA_form', 'season_form',\n",
    "]\n",
    "fixtures = get_interaction_terms(fixtures, interaction_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "non_informative_cols = [\n",
    "    'match_id',\n",
    "    'date',\n",
    "    'season',\n",
    "    'team_id',\n",
    "    'team_name',\n",
    "    'opposition_id',\n",
    "    'opposition_name',\n",
    "    'scored',\n",
    "    'conceded',\n",
    "    'win'\n",
    "]\n",
    "fixture_features = ['average_hth_points', 'average_hth_relative_score']\n",
    "team_features = [feat for feat in interaction_features if feat not in fixture_features]\n",
    "team_features += ['_'.join(['opposition', feat]) for feat in team_features]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can look at the correlation with relative score with our new interaction variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "AB                                  0.414225\n",
       "CE                                  0.409555\n",
       "BF                                  0.407405\n",
       "EF                                  0.404316\n",
       "AD                                  0.403773\n",
       "AE                                  0.403741\n",
       "relative_season_average_scored      0.400154\n",
       "relative_season_average_points      0.399421\n",
       "AG                                  0.392420\n",
       "BC                                  0.391758\n",
       "relative_HA_average_points          0.386124\n",
       "CG                                  0.385335\n",
       "relative_HA_average_scored          0.385074\n",
       "DF                                  0.382687\n",
       "relative_league_position            0.380187\n",
       "EH                                  0.375639\n",
       "GH                                  0.375033\n",
       "FG                                  0.374237\n",
       "DH                                  0.365644\n",
       "BH                                  0.363635\n",
       "AH                                  0.361073\n",
       "CD                                  0.355976\n",
       "AF                                  0.303988\n",
       "relative_season_average_conceded    0.299856\n",
       "HI                                  0.285919\n",
       "FH                                  0.284503\n",
       "relative_HA_average_conceded        0.283081\n",
       "relative_HA_form                    0.274045\n",
       "CH                                  0.269648\n",
       "relative_season_form                0.266496\n",
       "CJ                                  0.263485\n",
       "HJ                                  0.261329\n",
       "GJ                                  0.261274\n",
       "FJ                                  0.258840\n",
       "HK                                  0.257138\n",
       "FK                                  0.255490\n",
       "GK                                  0.253635\n",
       "EJ                                  0.253035\n",
       "DJ                                  0.251384\n",
       "AJ                                  0.251274\n",
       "CK                                  0.250794\n",
       "AK                                  0.247954\n",
       "BJ                                  0.247404\n",
       "EK                                  0.244411\n",
       "DK                                  0.244138\n",
       "BK                                  0.242215\n",
       "home                                0.201798\n",
       "Name: relative_score, dtype: float64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cols_to_drop = non_informative_cols + team_features + fixture_features\n",
    "relative_score_corr = fixtures.drop(cols_to_drop, axis=1).corr()['relative_score'].abs()\n",
    "relative_score_corr[relative_score_corr > 0.2].sort_values(ascending=False)[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It looks like some of the interaction variables will be useful predictors, although it is likely some of the variables will be highly correlated. Before I do any modelling I will remove highly correlated variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EDA\n",
    "\n",
    "Now the target is the 'win' column, so first I will look at the variance of the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,6))\n",
    "ax = sns.countplot(fixtures['win'])\n",
    "no_fixtures = len(fixtures)\n",
    "plt.title('Target Variation')\n",
    "\n",
    "for p in ax.patches:\n",
    "    x = p.get_bbox().get_points()[:,0]\n",
    "    y = p.get_height()\n",
    "    ax.annotate(f'{100*y/no_fixtures:.2f}%', (x.mean(), y), ha='center', va='bottom')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As each fixture is repeated twice, the difference can be accounted for by the number of draws. \n",
    "\n",
    "Let's look at how the 'home' indicator effects the distribution of wins."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(61.0, 0.5, 'Home')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "home_win_count = fixtures.pivot_table(index='home', columns='win', values='team_id', aggfunc='count')\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.title('Heatmap Showing Count of Wins Against Home Game Indicator')\n",
    "sns.heatmap(home_win_count, annot=True, fmt='g', cmap='Blues')\n",
    "plt.xlabel('Win')\n",
    "plt.ylabel('Home')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The heatmap shows that winning is more likley when playing at home and losing/drawing is more likley when playing away, therefore this will be a useful feature for prediction.\n",
    "\n",
    "Now let's look if any of the features help to distinguish which team wins, again we will use the relative columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "relative_cols = [\n",
    "    'relative_HA_average_scored',\n",
    "    'relative_season_average_scored',\n",
    "    'relative_HA_average_conceded',\n",
    "    'relative_season_average_conceded',\n",
    "    'relative_HA_average_points',\n",
    "    'relative_season_average_points',\n",
    "    'relative_HA_form',\n",
    "    'relative_season_form',\n",
    "    'average_hth_points',\n",
    "    'average_hth_relative_score',\n",
    "    'relative_league_position',\n",
    "]\n",
    "target_col = 'win'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can visualise any difference in distribution of the features based on the target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x1944 with 11 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(\n",
    "    int(np.ceil(len(relative_cols)/2)), 2, \n",
    "    figsize=(12, 5*len(relative_cols)//2))\n",
    "\n",
    "# Remove last axes if odd features\n",
    "if len(relative_cols)%2 != 0:\n",
    "    fig.delaxes(axes[len(relative_cols)//2, 1])\n",
    "\n",
    "# Plot axes\n",
    "for ax, feature in enumerate(relative_cols):\n",
    "    sns.boxplot(x=fixtures['win'], y=fixtures[feature], orient='v', ax=axes[ax//2, ax%2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predict relative score\n",
    "\n",
    "Let's once again try predicting the relative score, so that the degree of a win can be included in the model. First, I will seperate a subset of the features I want to use for modelling. The easiest way to do this will be to remove non informative columns and features that were soley useful for creating new features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixtures_2019 = fixtures[fixtures['season'] == 2019].reset_index(drop=True)\n",
    "fixtures = fixtures[fixtures['season'] != 2019].reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "non_feature_cols = [\n",
    "    'match_id', 'date', 'season', 'team_id', 'team_name', 'opposition_id',\n",
    "    'opposition_name', 'scored', 'conceded', 'league_position', \n",
    "    'opposition_league_position',\n",
    "    'HA_average_scored', 'opposition_HA_average_scored', 'HA_average_conceded',\n",
    "    'opposition_HA_average_conceded', 'HA_average_points',\n",
    "    'opposition_HA_average_points', 'HA_form', 'opposition_HA_form',\n",
    "    'season_average_scored', 'opposition_season_average_scored',\n",
    "    'season_average_conceded', 'opposition_season_average_conceded',\n",
    "    'season_average_points', 'opposition_season_average_points',\n",
    "    'season_form', 'opposition_season_form',\n",
    "    'games_played', 'win'\n",
    "]\n",
    "features_subset = fixtures.drop(non_feature_cols, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can remove features that have a low correlation with relative score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "realtive_score_corr = features_subset.corr()['relative_score'].abs()\n",
    "features = relative_score_corr[relative_score_corr > 0.1].index\n",
    "features_subset = features_subset[features]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to remove features that have a high correlation. I will do this using a function that finds features that have a correlation over a threshold and then removes the feature with the lowest correlation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drop_correlated_features(dataframe, target, threshold):\n",
    "    \"\"\"\n",
    "    Recursively finds the most highly correlated features (Pearson correlation)\n",
    "    over the correlation threshold and then removes the feature with the least\n",
    "    correlation (Pearson or Point Biserial if binary target) with the target variable.\n",
    "    \"\"\"\n",
    "    # Compute feature correlations\n",
    "    features = dataframe.drop(target, axis=1)\n",
    "    bool_cols = [col for col in features \n",
    "             if np.isin(features[col].dropna().unique(), [0, 1]).all()]\n",
    "    continuous_features = features.drop(bool_cols, axis=1)\n",
    "    features_corr = continuous_features.corr().abs()\n",
    "    \n",
    "    # Take the upper triangle of feature correlations\n",
    "    features_corr = features_corr.mask(np.tril(np.ones(features_corr.shape, dtype=np.bool_)))\n",
    "    \n",
    "    # Find index of correlations greater than the threshold\n",
    "    correlated_features = zip(*np.where(features_corr > threshold))\n",
    "    \n",
    "    # Create dict, correlated features tuple : correlation\n",
    "    correlated_features = {\n",
    "        (features_corr.columns[i], features_corr.columns[j]): features_corr.iloc[i,j]\n",
    "        for i,j in correlated_features\n",
    "    }\n",
    "    \n",
    "    # If no correlations above threshold, return the dataframe\n",
    "    if not correlated_features:\n",
    "        return dataframe\n",
    "    \n",
    "    # Find most highly correlated features\n",
    "    max_corr_features = max(correlated_features, key=correlated_features.get)\n",
    "    \n",
    "    # Set correlation metric\n",
    "    correlation_metric = pearsonr\n",
    "    if np.isin(dataframe[target].unique(), [0, 1]).all():\n",
    "        correlation_metric = pointbiserialr\n",
    "    \n",
    "    # Find point correlation with target\n",
    "    corrs_with_target = {\n",
    "        feature: abs(correlation_metric(dataframe[target], dataframe[feature])[0])\n",
    "        for feature in max_corr_features}\n",
    "\n",
    "    # Drop feature with the least correlation with target\n",
    "    feature_to_drop = min(corrs_with_target, key=corrs_with_target.get)\n",
    "    new_dataframe = dataframe.drop(feature_to_drop, axis=1)\n",
    "    \n",
    "    return drop_correlated_features(new_dataframe, target, threshold)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I will set the threshold at 0.9 and see how the prediction performs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "features_subset = drop_correlated_features(features_subset, 'relative_score', 0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I want to keep the 2019 set of fixtures out of the modelling to simulate my end model on betting data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = features_subset.drop('relative_score', axis=1)\n",
    "y = features_subset['relative_score']\n",
    "X_2019 = fixtures_2019[X.columns]\n",
    "y_2019 = fixtures_2019['relative_score']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train Models\n",
    "\n",
    "First, we split our data into a training and test set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train test split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I can scale the non binary features features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scale_features(X_train, X_test):\n",
    "    \"\"\"\n",
    "    Fit scaler on X_train continuous features and transform continuous features\n",
    "    in X_train and X_test.\n",
    "    Input: X_train, X_test\n",
    "    Output: X_train, X_test\n",
    "    \"\"\"\n",
    "    bool_cols = [col for col in X_train\n",
    "                 if np.isin(X_train[col].dropna().unique(), [0, 1]).all()]\n",
    "    continuous_cols = [col for col in X_train.columns if col not in bool_cols]\n",
    "    \n",
    "    scaler = StandardScaler()\n",
    "    scaler.fit(X_train[continuous_cols])\n",
    "    \n",
    "    scaled_X_train = pd.DataFrame(\n",
    "        scaler.transform(X_train[continuous_cols]),\n",
    "        columns=continuous_cols, index=X_train.index)\n",
    "    scaled_X_train = pd.concat([scaled_X_train, X_train[bool_cols]], axis=1)\n",
    "    \n",
    "    scaled_X_test = pd.DataFrame(\n",
    "        scaler.transform(X_test[continuous_cols]),\n",
    "        columns=continuous_cols, index=X_test.index)\n",
    "    scaled_X_test = pd.concat([scaled_X_test, X_test[bool_cols]], axis=1)\n",
    "    \n",
    "    return scaled_X_train, scaled_X_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test = scale_features(X_train, X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MRSE:  1.6711184012432319\n"
     ]
    }
   ],
   "source": [
    "# Train linear regression\n",
    "lin_reg = LinearRegression()\n",
    "MSEs = cross_val_score(lin_reg, X_train, y_train, scoring='neg_mean_squared_error', cv=5)\n",
    "mean_MRSE = np.mean(np.sqrt(abs(MSEs)))\n",
    "print('RMSE: ', mean_MRSE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 0.01}\n",
      "Best CV MRSE:  1.6703923167415475\n",
      "\n",
      "\n",
      "Test MRSE:  1.6185578491372965\n",
      "Test MAE:  1.2550757728889024\n"
     ]
    }
   ],
   "source": [
    "# Train lasso\n",
    "lasso = Lasso(max_iter=100000)\n",
    "parameters = {'alpha': [1e-15, 1e-10, 1e-8, 1e-4, 1e-3, 1e-2, 1, 5, 10, 20]}\n",
    "lasso_reg = GridSearchCV(lasso, parameters, scoring='neg_mean_squared_error', cv=5)\n",
    "lasso_reg.fit(X_train, y_train)\n",
    "print(lasso_reg.best_params_)\n",
    "print('Best CV MRSE: ', np.sqrt(abs(lasso_reg.best_score_)))\n",
    "print('\\n')\n",
    "\n",
    "predictions = lasso_reg.best_estimator_.predict(X_test)\n",
    "MSE = mean_squared_error(y_test, predictions)\n",
    "MAE = mean_absolute_error(y_test, predictions)\n",
    "print('Test RMSE: ', np.sqrt(MSE))\n",
    "print('Test MAE: ', MAE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 20}\n",
      "Best CV MRSE:  1.6711645246145106\n",
      "\n",
      "\n",
      "Test MRSE:  1.6167418434379195\n",
      "Test MAE:  1.2555251772411302\n"
     ]
    }
   ],
   "source": [
    "# Train ridge\n",
    "ridge = Ridge(max_iter=100000)\n",
    "parameters = {'alpha': [1e-15, 1e-10, 1e-8, 1e-4, 1e-3, 1e-2, 1, 5, 10, 20, 40, 60, 80]}\n",
    "ridge_reg = GridSearchCV(ridge, parameters, scoring='neg_mean_squared_error', cv=5)\n",
    "ridge_reg.fit(X_train, y_train)\n",
    "print(ridge_reg.best_params_)\n",
    "print('Best CV MRSE: ', np.sqrt(abs(ridge_reg.best_score_)))\n",
    "print('\\n')\n",
    "\n",
    "predictions = ridge_reg.best_estimator_.predict(X_test)\n",
    "MSE = mean_squared_error(y_test, predictions)\n",
    "MAE = mean_absolute_error(y_test, predictions)\n",
    "print('Test RMSE: ', np.sqrt(MSE))\n",
    "print('Test MAE: ', MAE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 1, 'epsilon': 1}\n",
      "Best CV MRSE:  1.6714213161461664\n",
      "\n",
      "\n",
      "Test MRSE:  1.6219677581740775\n",
      "Test MAE:  1.2610591309209267\n"
     ]
    }
   ],
   "source": [
    "# Linear SVR\n",
    "linsvr = SVR(kernel='linear')\n",
    "parameters = {\n",
    "    'C': [1e-4, 1e-3, 1e-2, 1, 5, 10, 20],\n",
    "    'epsilon': [1e-8, 1e-4, 1e-3, 1e-2, 1, 5, 10, 20]}\n",
    "linsvr_reg = GridSearchCV(linsvr, parameters, scoring='neg_mean_squared_error', cv=5)\n",
    "linsvr_reg.fit(X_train, y_train)\n",
    "print(linsvr_reg.best_params_)\n",
    "print('Best CV MRSE: ', np.sqrt(abs(linsvr_reg.best_score_)))\n",
    "print('\\n')\n",
    "\n",
    "predictions = linsvr_reg.best_estimator_.predict(X_test)\n",
    "MSE = mean_squared_error(y_test, predictions)\n",
    "MAE = mean_absolute_error(y_test, predictions)\n",
    "print('Test RMSE: ', np.sqrt(MSE))\n",
    "print('Test MAE: ', MAE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C': 1, 'epsilon': 1}\n",
      "Best CV MRSE:  1.693097449502652\n",
      "\n",
      "\n",
      "Test MRSE:  1.6368194080647671\n",
      "Test MAE:  1.2690757148067013\n"
     ]
    }
   ],
   "source": [
    "# RBF SVR\n",
    "rbfsvr = SVR(kernel='rbf',)\n",
    "parameters = {\n",
    "    'C': [1e-4, 1e-3, 1e-2, 1, 5, 10, 20],\n",
    "    'epsilon': [1e-8, 1e-4, 1e-3, 1e-2, 1, 5, 10, 20]}\n",
    "rbfsvr_reg = GridSearchCV(rbfsvr, parameters, scoring='neg_mean_squared_error', cv=5)\n",
    "rbfsvr_reg.fit(X_train, y_train)\n",
    "print(rbfsvr_reg.best_params_)\n",
    "print('Best CV MRSE: ', np.sqrt(abs(rbfsvr_reg.best_score_)))\n",
    "print('\\n')\n",
    "\n",
    "predictions = rbfsvr_reg.best_estimator_.predict(X_test)\n",
    "MSE = mean_squared_error(y_test, predictions)\n",
    "MAE = mean_absolute_error(y_test, predictions)\n",
    "print('Test RMSE: ', np.sqrt(MSE))\n",
    "print('Test MAE: ', MAE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is marginal difference between the different regression algorithms but I will use ridge regression to predict the score of each match. Now we want to predict the relative score of all of our matches so we can use it as a feature when predicting if a team will win."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, X = scale_features(X_train, X)\n",
    "_, X_2019 = scale_features(X_train, X_2019)\n",
    "\n",
    "predicted_scores = pd.Series(\n",
    "    ridge_reg.best_estimator_.predict(X), name='predicted_relative_score')\n",
    "predicted_scores_2019 = pd.Series(\n",
    "    ridge_reg.best_estimator_.predict(X_2019), name='predicted_relative_score')\n",
    "\n",
    "features = pd.concat([\n",
    "    fixtures.drop(non_feature_cols, axis=1), predicted_scores, fixtures['win']], axis=1)\n",
    "fixtures_2019 = pd.concat([fixtures_2019, predicted_scores_2019], axis=1)\n",
    "\n",
    "features = features.drop('relative_score', axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Win classifier\n",
    "\n",
    "Again I want to drop highly correlated variables, this time the target is binary so the correlation metric used between continuous features and binary target will be Point Biserial correlation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "features = drop_correlated_features(features, 'win', 0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I need to split my data into training and testing sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train test split\n",
    "X = features.drop('win', axis=1)\n",
    "y = features['win']\n",
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "    X, y, test_size=0.3, random_state=42, stratify=y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I will scale the features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test = scale_features(X_train, X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I want to train my model so that it has as high as possible precision but also classifies as many wins as possible. I'm going to create a scorer that places importance on both precision and recall but more so on precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "beta = 0.5\n",
    "fbeta = make_scorer(fbeta_score, beta=beta, average='binary', pos_label=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I will define a function to print the evaluation metrics I will use to compare the models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_model_eval(model, X_test, y_test, beta):\n",
    "    \"\"\"\n",
    "    This function prints the weighted F1 score, confusion matrix and classification\n",
    "    report.\n",
    "    Input:\n",
    "        - Model: Trained machine learning model.\n",
    "        - X_test: Test features.\n",
    "        - y_test: Test target.\n",
    "        - beta: Beta argument for fbeta_score.\n",
    "    \"\"\"\n",
    "    predictions = model.predict(X_test)\n",
    "    print('Weighted F1 Score: ', fbeta_score(y_test, predictions, beta))\n",
    "    print('\\n')\n",
    "    print('Confusion Matrix:')\n",
    "    print(confusion_matrix(y_test, predictions))\n",
    "    print('\\n')\n",
    "    print(classification_report(y_test, predictions))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'C': 0.01}\n",
      "Weighted F1 Score:  0.5756052992233895\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[844 143]\n",
      " [357 252]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.70      0.86      0.77       987\n",
      "         1.0       0.64      0.41      0.50       609\n",
      "\n",
      "    accuracy                           0.69      1596\n",
      "   macro avg       0.67      0.63      0.64      1596\n",
      "weighted avg       0.68      0.69      0.67      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Logistic regression\n",
    "log = LogisticRegression(max_iter=10000)\n",
    "parameters = {'C': [1e-15, 1e-10, 1e-8, 1e-4, 1e-3, 1e-2, 1, 5, 10, 20]}\n",
    "log_grid = GridSearchCV(log, parameters, scoring=fbeta, cv=5)\n",
    "log_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', log_grid.best_params_)\n",
    "print_model_eval(log_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'C': 1}\n",
      "Weighted F1 Score:  0.5404671374253123\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[878 109]\n",
      " [410 199]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.68      0.89      0.77       987\n",
      "         1.0       0.65      0.33      0.43       609\n",
      "\n",
      "    accuracy                           0.67      1596\n",
      "   macro avg       0.66      0.61      0.60      1596\n",
      "weighted avg       0.67      0.67      0.64      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Linear SVC\n",
    "linear_svc = SVC(kernel='linear')\n",
    "parameters = {'C': [1e-3, 1e-2, 0.1, 1, 5, 10, 100]}\n",
    "linsvc_grid = GridSearchCV(linear_svc, parameters, scoring=fbeta, cv=5)\n",
    "linsvc_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', linsvc_grid.best_params_)\n",
    "print_model_eval(linsvc_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'n_neighbors': 15}\n",
      "Weighted F1 Score:  0.5325443786982249\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[824 163]\n",
      " [375 234]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.69      0.83      0.75       987\n",
      "         1.0       0.59      0.38      0.47       609\n",
      "\n",
      "    accuracy                           0.66      1596\n",
      "   macro avg       0.64      0.61      0.61      1596\n",
      "weighted avg       0.65      0.66      0.64      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# K neighbours\n",
    "neighbours = KNeighborsClassifier()\n",
    "parameters = {'n_neighbors': np.linspace(5,15,num=5,dtype='int')}\n",
    "neighbours_grid = GridSearchCV(neighbours, parameters, scoring=fbeta, cv=5)\n",
    "neighbours_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', neighbours_grid.best_params_)\n",
    "print_model_eval(neighbours_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'C': 1, 'gamma': 0.1}\n",
      "Weighted F1 Score:  0.5325593134780414\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[855 132]\n",
      " [398 211]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.68      0.87      0.76       987\n",
      "         1.0       0.62      0.35      0.44       609\n",
      "\n",
      "    accuracy                           0.67      1596\n",
      "   macro avg       0.65      0.61      0.60      1596\n",
      "weighted avg       0.66      0.67      0.64      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# RBF SVC\n",
    "rbf_svc = SVC(kernel='rbf')\n",
    "parameters = {'gamma': [0.1, 1, 10, 100], 'C': [0.1, 1, 10, 100, 1000]}\n",
    "rbfsvc_grid = GridSearchCV(rbf_svc, parameters, scoring=fbeta, cv=5)\n",
    "rbfsvc_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', rbfsvc_grid.best_params_)\n",
    "print_model_eval(rbfsvc_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'n_estimators': 100, 'min_samples_split': 10, 'max_features': 10, 'max_depth': 5}\n",
      "Weighted F1 Score:  0.5623529411764706\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[847 140]\n",
      " [370 239]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.70      0.86      0.77       987\n",
      "         1.0       0.63      0.39      0.48       609\n",
      "\n",
      "    accuracy                           0.68      1596\n",
      "   macro avg       0.66      0.63      0.63      1596\n",
      "weighted avg       0.67      0.68      0.66      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Random Forest\n",
    "forest = RandomForestClassifier()\n",
    "parameters = {\n",
    "    'min_samples_split': [2, 5, 10], \n",
    "    'n_estimators' : [100, 300],\n",
    "    'max_depth': [5, 25, None],\n",
    "    'max_features': [3, 10, 25, 'auto']\n",
    "}\n",
    "forest_grid = RandomizedSearchCV(forest, parameters, scoring=fbeta, cv=5, n_iter=40)\n",
    "forest_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', forest_grid.best_params_)\n",
    "print_model_eval(forest_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Params:  {'min_child_weight': 3, 'max_depth': 3, 'gamma': 0.2, 'eta': 0.1, 'colsample_bytree': 0.3}\n",
      "Weighted F1 Score:  0.5623582766439909\n",
      "\n",
      "\n",
      "Confusion Matrix:\n",
      "[[836 151]\n",
      " [361 248]]\n",
      "\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.70      0.85      0.77       987\n",
      "         1.0       0.62      0.41      0.49       609\n",
      "\n",
      "    accuracy                           0.68      1596\n",
      "   macro avg       0.66      0.63      0.63      1596\n",
      "weighted avg       0.67      0.68      0.66      1596\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Gradient Boosted Tree\n",
    "xgboost = XGBClassifier()\n",
    "parameters = {\n",
    "    'eta': [0.05, 0.10, 0.15, 0.20, 0.25, 0.30],\n",
    "    'max_depth': [3, 4, 5, 6, 8, 10, 12, 15],\n",
    "    'min_child_weight': [1, 3, 5, 7],\n",
    "    'gamma': [0.0, 0.1, 0.2, 0.3, 0.4],\n",
    "    'colsample_bytree': [0.3, 0.4, 0.5, 0.7]\n",
    "}\n",
    "xgboost_grid = RandomizedSearchCV(xgboost, parameters, scoring=fbeta, cv=5, n_iter=40, n_jobs=-1)\n",
    "xgboost_grid.fit(X_train, y_train)\n",
    "\n",
    "print('Best Params: ', xgboost_grid.best_params_)\n",
    "print_model_eval(xgboost_grid.best_estimator_, X_test, y_test, beta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The logistic regression model has the best fbeta score on the test set. I will use this as the best model for the betting simulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model = log_grid.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Betting Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds_data_path = os.path.join(data_path, 'odds', 'prem_2019_odds.csv')\n",
    "odds = pd.read_csv(odds_data_path, parse_dates=['Date'])\n",
    "odds = odds[['Date', 'HomeTeam', 'AwayTeam', 'MaxH', 'MaxA']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a few teams in the odds data set that have different names to the fixtures data set, so those need to be changed first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "team_name_map = {\n",
    "    'Man United': \"Manchester United\",\n",
    "    'Man City': \"Manchester City\",\n",
    "    'Sheffield United': \"Sheffield Utd\",\n",
    "}\n",
    "odds['HomeTeam'] = odds['HomeTeam'].apply(lambda x: team_name_map.get(x, x))\n",
    "odds['AwayTeam'] = odds['AwayTeam'].apply(lambda x: team_name_map.get(x, x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I can add the betting odds for winning to the fixtures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_odds(odds, team, opposition, home):\n",
    "    \"\"\"Returns the best betting odds for the team winning the match.\"\"\"\n",
    "    home_team = team if home else opposition\n",
    "    away_team = opposition if home else team\n",
    "    \n",
    "    home_team = odds['HomeTeam'] == home_team\n",
    "    away_team = odds['AwayTeam'] == away_team\n",
    "    match = odds.loc[home_team & away_team]\n",
    "    match = match.iloc[0]\n",
    "    \n",
    "    odds = match['MaxH'] if home else match['MaxA']\n",
    "    return odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "fixtures_2019['odds'] = fixtures_2019.apply(\n",
    "    lambda x: get_odds(odds, x['team_name'], x['opposition_name'], x['home']), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I will use my model to predict if the team will win the match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, X_2019 = scale_features(X_train, fixtures_2019[X_train.columns])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions_2019 = pd.Series(best_model.predict(X_2019), name='win_prediction')\n",
    "fixtures_2019 = pd.concat([fixtures_2019, predictions_2019], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that I have the predictions and the odds I can choose which matches to bet on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bets made:  167\n",
      "Return:  160.28000000000003\n",
      "Percent return:  0.9597604790419163\n"
     ]
    }
   ],
   "source": [
    "bet_made = fixtures_2019[(fixtures_2019['win_prediction'] == 1)]\n",
    "bet_return = (bet_made['win'] * bet_made['odds']).sum()\n",
    "print('Bets made: ', len(bet_made))\n",
    "print('Return: ', bet_return)\n",
    "print('Percent return: ', bet_return/len(bet_made))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model has not given a positive return."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 4.02%\n"
     ]
    }
   ],
   "source": [
    "print(f'Loss: {100 * (1 - bet_return/len(bet_made)):.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unfortunately, the model gives a loss of 4.02%. This, although disappointing, is not entirely surprising as the betting companies are very good at giving odds for games so that they make profit.\n",
    "\n",
    "#### Improvements\n",
    "\n",
    "To improve the model it would be to perform a more in depth analysis of the games played. Using information about individual players, injuries, possesion etc. would give a interesting analysis of how different teams perform."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "football_predictions",
   "language": "python",
   "name": "football_predictions"
  },
  "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}