EPL Match Results DF.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from numpy import random \n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions below add several numerical features to my dataset. Consult doc strings for functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "#### Function 1\n",
    "def all_time_win_ratio(train_df,test_df):\n",
    "    \"\"\"\"\n",
    "    This function pulls a team list, iteratives over it to fill a dictionary, and maps the dictionary to a new column in\n",
    "    the data frame. Win ratio is number of wins/number of games.\n",
    "    \"\"\"\n",
    "    train_df.reset_index(inplace=True)\n",
    "    team_list = train_df.HomeTeam.unique()\n",
    "    all_time_ratio = {}\n",
    "    for team in team_list:\n",
    "        all_games = train_df.loc[train_df['team'] == team]\n",
    "        win_ratio = len(all_games[all_games['Points'] == 3])/len(all_games)\n",
    "        all_time_ratio[team] = win_ratio\n",
    "    train_df['opp_win_ratio'] = train_df['opponent'].map(all_time_ratio)\n",
    "    test_df['opp_win_ratio'] = test_df['opponent'].map(all_time_ratio)\n",
    "    return train_df\n",
    "\n",
    "#### Function 2\n",
    "def win_ratio_head2head(train_df,test_df):\n",
    "    \"\"\"\"\n",
    "    This function calculates a team's head to head win ratio with every opponent. Outer for loop iterates over a team list,\n",
    "    inner for loop iterates over every one of that team's opponents. Win ratio against each opponent is calculated and \n",
    "    stored in a dict. Dict is mapped to a new column and the dataframe chunk containing the original team's games is appended\n",
    "    to a list. After both loops close, all the dataframe chunks are concatenated back together.\n",
    "    \"\"\"\n",
    "    team_list = list(train_df.HomeTeam.unique())\n",
    "    team_list.append('Bournemouth')\n",
    "    train_chunks = []\n",
    "    test_chunks = []\n",
    "    train_df.reset_index(inplace=True)\n",
    "    test_df.reset_index(inplace=True)\n",
    "    for team in team_list:\n",
    "        train_team_games = train_df[train_df['team'] == team]\n",
    "        test_team_games = test_df[test_df['team'] == team]\n",
    "        head2head = {}\n",
    "        opponents = train_team_games['opponent'].unique()\n",
    "        for opponent in opponents:\n",
    "            wins = len(train_team_games.loc[(train_team_games['opponent']==opponent) & (train_team_games['Points'] == 3)])\n",
    "            total = len(train_team_games.loc[(train_team_games['opponent'] == opponent)])\n",
    "            if wins > 0:\n",
    "                win_ratio = wins/total\n",
    "            else:\n",
    "                win_ratio = 0\n",
    "            head2head[opponent] = win_ratio\n",
    "        train_team_games['head2head_win_ratio'] = train_team_games['opponent'].map(head2head)\n",
    "        test_team_games['head2head_win_ratio'] = test_team_games['opponent'].map(head2head)\n",
    "        train_chunks.append(train_team_games)\n",
    "        test_chunks.append(test_team_games)\n",
    "    train_dataframe = pd.concat(train_chunks,ignore_index=True)\n",
    "    test_dataframe = pd.concat(test_chunks, ignore_index=True)\n",
    "    return train_dataframe, test_dataframe\n",
    "\n",
    "#### Function 3\n",
    "def add_league_position(df1,df2):\n",
    "    \"\"\"\n",
    "    This function takes two dataframes, the matches DF and the league table DF and adds each opponent's league position\n",
    "    from last year as a feature. Because we care about a team's previous year results, two list comprehensions are used to \n",
    "    create a seasons list and an offset list. The offset list drops the first season and the seasons list drops the last\n",
    "    season. They are still the same length, but the first season in the offset list is now the second season in the season\n",
    "    list. This will be used when slicing the two dataframes by the i'th element in the list. Iterating over a range that's \n",
    "    the length of the lists lets us work season by season to slice the info we need from the league table DF. Zipping the \n",
    "    teams for each season with their respective finishing position gives a dict which is then mapped to a slice of the \n",
    "    matches DF. Because of the difference between the offset list and the seasons list, the slice of the matches DF is for\n",
    "    the season after the key-value pairs contained in the dict. This gives the feature opponent's league finish LAST YEAR.\n",
    "    Again, chunks are added to a list and then concatenated back together at the end of the function.\n",
    "    \"\"\"\n",
    "    seasons_list1 = double_df['Season'].unique()\n",
    "    seasons_list2 = seasons.year.unique()\n",
    "    seasons_offset = [x for x in seasons_list1 if x in seasons_list2]\n",
    "    seasons_offset.remove('1993-94')\n",
    "    seasons_list1 = double_df['Season'].unique()\n",
    "    seasons_list2 = seasons.year.unique()\n",
    "    seasons_list = [x for x in seasons_list1 if x in seasons_list2]\n",
    "    seasons_list.remove('2016-17')\n",
    "    chunk_list = []\n",
    "    for i in range(len(seasons_offset)):\n",
    "        current = df2[df2['year']==seasons_list[i]]\n",
    "        teams = current['Team']\n",
    "        pos = current['Pos']\n",
    "        dictionary = dict(zip(teams,pos))\n",
    "        chunk = df1[df1['Season']==seasons_offset[i]]\n",
    "        chunk['Opp_League_Finish_Last_Year'] = chunk['opponent'].map(dictionary)\n",
    "        chunk_list.append(chunk)\n",
    "    dataframe = pd.concat(chunk_list,ignore_index=True)\n",
    "    return dataframe\n",
    "\n",
    "#### Function 4\n",
    "def home_away_numerical(df):\n",
    "    \"\"\"\n",
    "    Simple function to assign a numerical value to whether a team is home/away. In this case, home=1 away=0. Same methodology\n",
    "    as above, chunk list to pd.concat().\n",
    "    \"\"\"\n",
    "    team_list = df.HomeTeam.unique()\n",
    "    chunks = []\n",
    "    for team in team_list:\n",
    "        all_games = df[df['team']==team]\n",
    "        all_games['HomeAway'] = 1\n",
    "        all_games.loc[all_games['AwayTeam']==team,'HomeAway'] = 0\n",
    "        chunks.append(all_games)\n",
    "    dataframe = pd.concat(chunks,ignore_index=True)\n",
    "    return dataframe\n",
    "\n",
    "#### Function 5\n",
    "def win_streak(df):\n",
    "    \"\"\"\n",
    "    Calculates a team's win streak. First iterates over a team list, pulls out all that team's games, intializes a list to\n",
    "    hold the count and sets a streak counter to 0. The inner for loop iterates over each row of the DF. Regardless of the \n",
    "    result the value of streak is appended to the streak_list and then the counter is updated. If the team won, the counter\n",
    "    is incremented up 1, if the team lost or tied it is reset to 0. When every row of a team's games has been iterated over,\n",
    "    the list is transposed directly to a new dataframe column. As above, DF chunks are appended to a list and then \n",
    "    concatenated at the very end.\n",
    "    \"\"\"\n",
    "    team_list = df['HomeTeam'].unique()\n",
    "    chunk_list = []\n",
    "    for team in team_list:\n",
    "        team_games = double_df.loc[(slice(None),team),:]\n",
    "        streak_list = []\n",
    "        streak = 0\n",
    "        for (season, team, date), data in team_games.iterrows():\n",
    "            if data['Points'] == 3:\n",
    "                streak_list.append(streak)\n",
    "                streak += 1\n",
    "            elif data['Points'] != 3: \n",
    "                streak_list.append(streak)\n",
    "                streak = 0\n",
    "        team_games['Streak'] = streak_list\n",
    "        chunk_list.append(team_games)\n",
    "    dataframe = pd.concat(chunk_list)\n",
    "    return dataframe\n",
    "\n",
    "#### Function 6\n",
    "def home_away_points(df, season):\n",
    "    \"\"\"\n",
    "    Function takes the matches DF and a given season, calculates mean home and away points, constructs a DF, and then plots\n",
    "    the results in a bar graph. The figures this function produces are in the written report and blog post.\n",
    "    \"\"\"\n",
    "    team_list = df.loc[season]['HomeTeam'].unique()\n",
    "    home_points= []\n",
    "    away_points = []\n",
    "    for team in team_list:\n",
    "        team_df = df.loc[(season,team)]\n",
    "        home = team_df['HomeTeam'] == team\n",
    "        away = team_df['AwayTeam'] == team\n",
    "        home_points.append(team_df.loc[home,'Points'].mean().round(2))\n",
    "        away_points.append(team_df.loc[away, 'Points'].mean().round(2))\n",
    "    dataframe = pd.DataFrame({'Teams':team_list,'Mean Home Points':home_points,'Mean Away Points' : away_points})\n",
    "    dataframe.set_index('Teams', inplace=True)\n",
    "    dataframe.plot(kind='Bar',title='Mean Home and Away Points in ' + season)\n",
    "    plt.savefig(season)\n",
    "\n",
    "#### Function 7    \n",
    "def cumulative_points(df,season):\n",
    "    \"\"\"\n",
    "    Function takes the matches DF and a season and plots the first place, mid table, and last place team's cumulative point\n",
    "    accumulation vs a randomized point allocation. \n",
    "    \"\"\"\n",
    "    team_list = df.loc[season]['HomeTeam'].unique()\n",
    "    most_least_list = []\n",
    "    most_least_dict = {}\n",
    "    for team in team_list:\n",
    "        last_year = df.loc[(season,team)]\n",
    "        most_least_list.append(last_year['Points'].sum())\n",
    "        most_least_dict[last_year['Points'].sum()] = team\n",
    "    most_least_list = sorted(most_least_list)\n",
    "    best_team = df.loc[(season,most_least_dict[most_least_list[-1]])]\n",
    "    mid_team = df.loc[(season,most_least_dict[most_least_list[9]])]\n",
    "    worst_team = df.loc[(season,most_least_dict[most_least_list[0]])]\n",
    "    best_team = best_team.reset_index(drop=True)\n",
    "    mid_team = mid_team.reset_index(drop=True)\n",
    "    worst_team = worst_team.reset_index(drop=True)\n",
    "    best_cum_points = best_team['Points'].cumsum()\n",
    "    best_cum_randoms = best_team['Random Points'].cumsum()\n",
    "    mid_cum_points = mid_team['Points'].cumsum()\n",
    "    mid_cum_randoms = mid_team['Random Points'].cumsum()\n",
    "    worst_cum_points = worst_team['Points'].cumsum()\n",
    "    worst_cum_randoms = worst_team['Random Points'].cumsum()\n",
    "    best_cum_points.plot(color='blue',label='Top Team Real Results')\n",
    "    best_cum_randoms.plot(color='red',label='Top Team Random Results')\n",
    "    mid_cum_points.plot(color='green', label = 'Mid Table Team Real Results')\n",
    "    mid_cum_randoms.plot(color='yellow', label='Mid Table Team Random Results')\n",
    "    worst_cum_points.plot(color='brown',label='Bottom Team Real Results')\n",
    "    worst_cum_randoms.plot(color='black',label='Bottom Team Random Results')\n",
    "    plt.xlabel('Games')\n",
    "    plt.ylabel('Points')\n",
    "    plt.title(\"Point Total from \" + season + ': Expected vs. Actual')\n",
    "    plt.legend(loc='upper left')\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "#### Function 8\n",
    "def results_and_points(df, team_list):\n",
    "    \"\"\"\n",
    "    Function takes matches DF and a team list and uses complex masking to simplify the target variable into a straightforward\n",
    "    points value. Of interest is real_x maskes. Random_x was just used to confirm that a random prediction model doesn't work. \n",
    "    \n",
    "    \"\"\"\n",
    "    for team in team_list:    \n",
    "        real_win = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['FTR'] =='H')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['FTR'] =='A'))\n",
    "        real_tie = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['FTR'] =='D')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['FTR'] =='D'))\n",
    "        real_loss = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['FTR'] =='A')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['FTR'] =='H'))\n",
    "        random_win = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['randomResult'] =='H')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['randomResult'] =='A'))\n",
    "        random_tie = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['randomResult'] =='D')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['randomResult'] =='D'))\n",
    "        random_loss = ((df['team'] == team) & (df['HomeTeam'] == team) & (df['randomResult'] =='A')) |((df['team'] == team) & (df['AwayTeam'] ==team) & (df['randomResult'] =='H'))\n",
    "        df.loc[real_win,'Points']=3\n",
    "        df.loc[real_tie,'Points']=1\n",
    "        df.loc[real_loss, 'Points']=0\n",
    "        df.loc[random_win, 'Random Points'] = 3\n",
    "        df.loc[random_tie, 'Random Points'] = 1\n",
    "        df.loc[random_loss, 'Random Points'] = 0\n",
    "    return df\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading in a dataframe of match results and season results and cleaning columns\n",
    "matches_path = 'C:/Users/nhcam/Desktop/Springboard/Premier League Betting Project/Data/Epl_Match_Results.csv'\n",
    "original_df = pd.read_csv(matches_path)\n",
    "original_df = original_df[['Date','HomeTeam','AwayTeam','FTHG','FTAG','FTR','Season']]\n",
    "original_df['Date'] = pd.to_datetime(original_df['Date'],dayfirst=True)\n",
    "\n",
    "#Adding random results with a random integer and changing all the 2's to 3's\n",
    "original_df['randomResult'] = np.random.randint(0,3,len(original_df))\n",
    "away_win = original_df['randomResult'] == 0\n",
    "draw = original_df['randomResult'] == 1\n",
    "home_win = original_df['randomResult'] == 2               \n",
    "original_df.loc[home_win,'randomResult'] = 'H'\n",
    "original_df.loc[draw, 'randomResult'] = 'D'\n",
    "original_df.loc[away_win, 'randomResult'] = 'A'\n",
    "\n",
    "#Loading in a second dataframe, seasons, to add league position as a feature in my original_df. Team names are recorded\n",
    "#differently than in my original_df, as were season titles, so a lot of strings had to be changed.\n",
    "season_path = 'C:/Users/nhcam/Desktop/Springboard/Premier League Betting Project/Data/seasons_result.csv'\n",
    "seasons = pd.read_csv(season_path,index_col= 'year')\n",
    "seasons = seasons.loc['2016/2017':'1993/1994'][['Team','W','L','D','F','A','Pts','Pos']]\n",
    "seasons = seasons.reset_index()\n",
    "seasons['year'] = seasons['year'].str.slice_replace(4,7,'-')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Manchester United', 'Man United')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Manchester City', 'Man City')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Tottenham Hotspurs', 'Tottenham')\n",
    "seasons['Team'] = seasons['Team'].str.replace('West Bromwich Albion', 'West Brom')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Birmingham City', 'Birmingham')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Blackburn Rovers', 'Blackburn')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Bolton Wanderers', 'Bolton')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Bradford City', 'Bradford')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Cardiff City', 'Cardiff')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Charlton Athletic', 'Charlton')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Coventry City', 'Coventry')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Derby County', 'Derby')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Hull City', 'Hull')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Ipswich Town', 'Ipswich')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Leeds United', 'Leeds')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Leicester City', 'Leicester')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Newcastle United', 'Newcastle')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Norwich City', 'Norwich')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Nottingham Forest', \"Nott'm Forest\")\n",
    "seasons['Team'] = seasons['Team'].str.replace('Queens Park Rangers', 'QPR')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Oldham Athletic','Oldham')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Sheffield Wednesday', 'Sheffield Weds')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Stoke City', 'Stoke')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Swansea City', 'Swansea')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Swindon Town', 'Swindon')\n",
    "seasons['Team'] = seasons['Team'].str.replace('West Bromwich Albion', 'West Brom')\n",
    "seasons['Team'] = seasons['Team'].str.replace('West Ham United','West Ham')\n",
    "seasons['Team'] = seasons['Team'].str.replace('Wolverhampton Wanderers','Wolves')\n",
    "seasons['year'] = seasons['year'].str.replace('2002-','2002-03')\n",
    "seasons['year'] = seasons['year'].str.replace('2003-','2003-04')\n",
    "seasons['year'] = seasons['year'].str.replace('2004-','2004-05')\n",
    "seasons['year'] = seasons['year'].str.replace('2005-','2005-06')\n",
    "\n",
    "team_list = original_df.HomeTeam.unique()\n",
    "pd.set_option('display.max_columns', 10)\n",
    "pd.set_option('display.width', 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following cell turns the dataframe I originally loaded into the format I need for analyzing matches. I had to copy the original and make new columns for both so that when I concatenated them together I could have all of a team's games represented in order by season. This cell also applies all the functions described above to obtain all my numerical features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {
    "scrolled": true
   },
   "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></th>\n",
       "      <th>HomeTeam</th>\n",
       "      <th>AwayTeam</th>\n",
       "      <th>FTHG</th>\n",
       "      <th>FTAG</th>\n",
       "      <th>FTR</th>\n",
       "      <th>...</th>\n",
       "      <th>Opp_League_Finish_Last_Year</th>\n",
       "      <th>Streak</th>\n",
       "      <th>head2head_win_ratio</th>\n",
       "      <th>opp_win_ratio</th>\n",
       "      <th>Result</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>team</th>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th rowspan=\"5\" valign=\"top\">Arsenal</th>\n",
       "      <th>2016-08-14</th>\n",
       "      <td>Arsenal</td>\n",
       "      <td>Liverpool</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>A</td>\n",
       "      <td>...</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0.309524</td>\n",
       "      <td>0.507481</td>\n",
       "      <td>Loss</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-20</th>\n",
       "      <td>Leicester</td>\n",
       "      <td>Arsenal</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>D</td>\n",
       "      <td>...</td>\n",
       "      <td>14.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.611111</td>\n",
       "      <td>0.274566</td>\n",
       "      <td>Draw</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-08-27</th>\n",
       "      <td>Watford</td>\n",
       "      <td>Arsenal</td>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>A</td>\n",
       "      <td>...</td>\n",
       "      <td>20.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.144737</td>\n",
       "      <td>Win</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-09-10</th>\n",
       "      <td>Arsenal</td>\n",
       "      <td>Southampton</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>H</td>\n",
       "      <td>...</td>\n",
       "      <td>7.0</td>\n",
       "      <td>1</td>\n",
       "      <td>0.535714</td>\n",
       "      <td>0.311567</td>\n",
       "      <td>Win</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2016-09-17</th>\n",
       "      <td>Hull</td>\n",
       "      <td>Arsenal</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>A</td>\n",
       "      <td>...</td>\n",
       "      <td>18.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0.750000</td>\n",
       "      <td>0.210526</td>\n",
       "      <td>Win</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 15 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                     HomeTeam     AwayTeam  FTHG  FTAG FTR  ... Opp_League_Finish_Last_Year Streak  head2head_win_ratio  opp_win_ratio  Result\n",
       "team    Date                                                ...                                                                               \n",
       "Arsenal 2016-08-14    Arsenal    Liverpool     3     4   A  ...                         6.0      1             0.309524       0.507481    Loss\n",
       "        2016-08-20  Leicester      Arsenal     0     0   D  ...                        14.0      0             0.611111       0.274566    Draw\n",
       "        2016-08-27    Watford      Arsenal     1     3   A  ...                        20.0      0             1.000000       0.144737     Win\n",
       "        2016-09-10    Arsenal  Southampton     2     1   H  ...                         7.0      1             0.535714       0.311567     Win\n",
       "        2016-09-17       Hull      Arsenal     1     4   A  ...                        18.0      2             0.750000       0.210526     Win\n",
       "\n",
       "[5 rows x 15 columns]"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.options.mode.chained_assignment = None\n",
    "original_df1 = original_df.copy()\n",
    "original_df1['team'] = original_df1['HomeTeam']\n",
    "original_df1['opponent'] = original_df1['AwayTeam']\n",
    "original_df['team'] = original_df1['AwayTeam']\n",
    "original_df['opponent'] = original_df1['HomeTeam']\n",
    "double_df = pd.concat([original_df,original_df1])\n",
    "\n",
    "\n",
    "double_df = results_and_points(double_df, team_list)\n",
    "double_df = home_away_numerical(double_df)\n",
    "double_df = add_league_position(double_df,seasons)\n",
    "double_df.set_index(['Season','team','Date'], inplace=True)\n",
    "double_df.sort_index(level = 0, inplace=True)\n",
    "\n",
    "double_df = win_streak(double_df)\n",
    "double_df.sort_index(level = 0, inplace=True)\n",
    "\n",
    "train_df = double_df['1994-95':'2014-15']\n",
    "test_df = double_df.loc['2016-17']\n",
    "\n",
    "train_df,test_df = win_ratio_head2head(train_df,test_df)\n",
    "\n",
    "train_df = all_time_win_ratio(train_df,test_df)\n",
    "\n",
    "\n",
    "train_df.set_index(['Season','team','Date'], inplace=True)\n",
    "\n",
    "train_df.sort_index(inplace=True, level = [0,1,2])\n",
    "test_df.set_index(['team','Date'],inplace=True)\n",
    "test_df.sort_index(inplace=True, level = [0,1])\n",
    "\n",
    "train_df['Opp_League_Finish_Last_Year'].fillna(20,inplace=True)\n",
    "test_df['Opp_League_Finish_Last_Year'].fillna(20,inplace=True)\n",
    "train_df['Result'] = 'Win'\n",
    "train_df.loc[train_df['Points'] == 1, 'Result'] = 'Draw'\n",
    "train_df.loc[train_df['Points']== 0, 'Result'] = 'Loss'\n",
    "test_df['Result'] = 'Win'\n",
    "test_df.loc[test_df['Points'] == 1, 'Result'] = 'Draw'\n",
    "test_df.loc[test_df['Points']== 0, 'Result'] = 'Loss'\n",
    "test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df['head2head_win_ratio'].fillna(0,inplace=True)\n",
    "test_df['opp_win_ratio'].fillna(0,inplace=True)\n",
    "\n",
    "train_two_target = train_df.copy()\n",
    "draws = train_two_target['Result']=='Draw'\n",
    "train_two_target.loc[draws,'Result'] = 'Loss'\n",
    "loss_draw = train_two_target['Result'] == 'Loss'\n",
    "train_two_target.loc[loss_draw,'Result'] = 'Loss/Draw'\n",
    "\n",
    "test_two_target = test_df.copy()\n",
    "draws = test_two_target['Result']=='Draw'\n",
    "test_two_target.loc[draws,'Result'] = 'Loss'\n",
    "loss_draw = test_two_target['Result'] == 'Loss'\n",
    "test_two_target.loc[loss_draw,'Result'] = 'Loss/Draw'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = train_two_target.drop(['index','opponent','FTHG','FTAG','HomeTeam','AwayTeam', 'Random Points','randomResult','FTR','Points',\n",
    "                      'Result'],axis = 1)\n",
    "y_train = train_two_target['Result']\n",
    "\n",
    "X_test = test_two_target.drop(['opponent','FTHG','FTAG','HomeTeam','AwayTeam', 'Random Points','randomResult','FTR','Points',\n",
    "                    'Result'],axis = 1)\n",
    "y_test = test_two_target['Result']\n",
    "#logreg_grid = LogisticRegression(multi_class='multinomial',solver = 'lbfgs',max_iter=1000)\n",
    "#params = {'C':[0.001, 0.01, 0.1, 1, 10, 100, 1000]}\n",
    "#CLF = GridSearchCV(logreg_grid,params,cv = 5,scoring='accuracy')\n",
    "#CLF.fit(X_train,y_train)\n",
    "#CLF.best_params_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\nhcam\\Anaconda3\\lib\\site-packages\\sklearn\\linear_model\\logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6776315789473685"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logreg = LogisticRegression(max_iter=1000, C = 0.1)\n",
    "logreg.fit(X_train,y_train)\n",
    "logreg.score(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "   Loss/Draw       0.74      0.86      0.80     10176\n",
      "         Win       0.67      0.49      0.57      5948\n",
      "\n",
      "   micro avg       0.72      0.72      0.72     16124\n",
      "   macro avg       0.71      0.67      0.68     16124\n",
      "weighted avg       0.72      0.72      0.71     16124\n",
      "\n",
      "[[ 0.97829247  0.01523804  0.04689889  4.36196881 -0.33830658]]\n",
      "Index(['HomeAway', 'Opp_League_Finish_Last_Year', 'Streak', 'head2head_win_ratio', 'opp_win_ratio'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "y_pred = logreg.predict(X_train)\n",
    "rep = classification_report(y_train,y_pred)\n",
    "print(rep)\n",
    "print(logreg.coef_)\n",
    "print(X_test.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 335,
   "metadata": {},
   "outputs": [],
   "source": [
    "bets_path = 'C:/Users/nhcam/Desktop/Springboard/Premier League Betting Project/Data/E0.csv'\n",
    "bets = pd.read_csv(bets_path)\n",
    "bets = bets[['Date','HomeTeam','AwayTeam','FTR','B365H','B365A']]\n",
    "team_list = test_df.HomeTeam.unique()\n",
    "team_list.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [],
   "source": [
    "def did_I_make_money(team_list,predictions,betting_odds):\n",
    "    \"\"\"\n",
    "    This function takes a list of teams, label predictions made by the model, and a dataframe of bettings odds and returns\n",
    "    a dataframe from dict of the number of bets and total profit/loss. First, three empty lists are initialized and two \n",
    "    counters are set to increment through the unlabeled predictions. Iterating over the team list, the predictions are \n",
    "    combined with the result to decide if a bet is placed or not. Anywhere where the model predicts a win becomes a $100\n",
    "    bet. Then, iterating over the dataframe team_bets created in the outer loop, conditional logic is used to calculate \n",
    "    profit or loss. If a bet is placed and the team wins, bet*decimal odds is calculated. If a bet is placed and the team \n",
    "    loses, a loss of $110 is posted. Several lists are appended to, a list of teams in alphabetical order to teams, length \n",
    "    of team_bets DF where a bet was placed to total_bets, and the sum of team_bets DF proft or loss to money_made_or_lost.\n",
    "    Counter is incremented at the end of the outside for loop. There are 38 games in a season, so if we look at predictions\n",
    "    in 38 section chunks we can get predictions for one team at a time. After both loops close a dict is made from the 3 lists\n",
    "    and then pushed to a DF and returned.\n",
    "    \"\"\"\n",
    "    teams = []\n",
    "    total_bets = []\n",
    "    money_made_or_lost = []\n",
    "    x=0\n",
    "    x1=38\n",
    "    for team in team_list:\n",
    "        team_odds = ((betting_odds['HomeTeam'] == team)|(betting_odds['AwayTeam'] == team))\n",
    "        team_bets = betting_odds.loc[team_odds]\n",
    "        team_pred = predictions[x:x1]\n",
    "        team_bets['Model Prediction'] = team_pred\n",
    "        team_bets['Bet'] = 100\n",
    "        no_win = team_bets['Model Prediction'] != 'Win' \n",
    "        team_bets.loc[no_win,'Bet'] = 0\n",
    "        team_bets['Profit/Loss'] = 0\n",
    "        profit_loss = []\n",
    "        for index,stats in team_bets.iterrows():\n",
    "            if (stats['HomeTeam'] == 'Bournemouth') | (stats['AwayTeam'] == 'Bournemouth'):\n",
    "                profit_loss.append(0)\n",
    "            elif stats['Model Prediction'] == 'Loss/Draw':\n",
    "                profit_loss.append(0)\n",
    "            elif (stats['Model Prediction'] == 'Win'):\n",
    "                if (stats['HomeTeam'] == team) & (stats['FTR'] == 'H'):\n",
    "                    profit_loss.append(stats['B365H'] * 100 - 100)\n",
    "                elif (stats['AwayTeam'] == team) & (stats['FTR'] == 'A'):\n",
    "                    profit_loss.append(stats['B365A'] * 100 - 100)\n",
    "                else:\n",
    "                    profit_loss.append(-100)                                       \n",
    "        team_bets['Profit/Loss'] = profit_loss\n",
    "        teams.append(team)\n",
    "        total_bets.append(len(team_bets.loc[team_bets['Bet'] == 100]))\n",
    "        money_made_or_lost.append(team_bets['Profit/Loss'].sum())\n",
    "        x += 38\n",
    "        x1 += 38\n",
    "    results = dict(zip(teams,zip(total_bets,money_made_or_lost)))\n",
    "    betting_results = pd.DataFrame.from_dict(results, orient='index',columns=['Total Bets Placed', 'Profit/Loss'])\n",
    "    return betting_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [],
   "source": [
    "betting_results = did_I_make_money(team_list,y_pred,bets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Total Bets Placed     191.0\n",
       "Profit/Loss          1024.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "betting_results.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "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>Total Bets Placed</th>\n",
       "      <th>Profit/Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Arsenal</th>\n",
       "      <td>20</td>\n",
       "      <td>134.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Bournemouth</th>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Burnley</th>\n",
       "      <td>3</td>\n",
       "      <td>60.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Chelsea</th>\n",
       "      <td>26</td>\n",
       "      <td>837.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Crystal Palace</th>\n",
       "      <td>7</td>\n",
       "      <td>-290.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Everton</th>\n",
       "      <td>12</td>\n",
       "      <td>347.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Hull</th>\n",
       "      <td>2</td>\n",
       "      <td>5.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Leicester</th>\n",
       "      <td>7</td>\n",
       "      <td>170.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Liverpool</th>\n",
       "      <td>17</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Man City</th>\n",
       "      <td>11</td>\n",
       "      <td>25.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Man United</th>\n",
       "      <td>26</td>\n",
       "      <td>-482.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Middlesbrough</th>\n",
       "      <td>9</td>\n",
       "      <td>-717.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Southampton</th>\n",
       "      <td>7</td>\n",
       "      <td>-37.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stoke</th>\n",
       "      <td>4</td>\n",
       "      <td>-10.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sunderland</th>\n",
       "      <td>5</td>\n",
       "      <td>-22.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Swansea</th>\n",
       "      <td>7</td>\n",
       "      <td>275.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tottenham</th>\n",
       "      <td>15</td>\n",
       "      <td>657.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Watford</th>\n",
       "      <td>1</td>\n",
       "      <td>-100.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>West Brom</th>\n",
       "      <td>3</td>\n",
       "      <td>65.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>West Ham</th>\n",
       "      <td>9</td>\n",
       "      <td>106.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                Total Bets Placed  Profit/Loss\n",
       "Arsenal                        20        134.0\n",
       "Bournemouth                     0          0.0\n",
       "Burnley                         3         60.0\n",
       "Chelsea                        26        837.0\n",
       "Crystal Palace                  7       -290.0\n",
       "Everton                        12        347.0\n",
       "Hull                            2          5.0\n",
       "Leicester                       7        170.0\n",
       "Liverpool                      17          1.0\n",
       "Man City                       11         25.0\n",
       "Man United                     26       -482.0\n",
       "Middlesbrough                   9       -717.0\n",
       "Southampton                     7        -37.0\n",
       "Stoke                           4        -10.0\n",
       "Sunderland                      5        -22.0\n",
       "Swansea                         7        275.0\n",
       "Tottenham                      15        657.0\n",
       "Watford                         1       -100.0\n",
       "West Brom                       3         65.0\n",
       "West Ham                        9        106.0"
      ]
     },
     "execution_count": 339,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "betting_results.head(20)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}