Home Court Advantage

%matplotlib inline

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np
import scipy

# a helper function to facilitate loading multiple csv files
def get_data(filename, columns=None):
    df = pd.read_csv(filename, sep=',', encoding='latin-1', \
                     skipinitialspace=True, index_col=1, usecols=columns)
    return df

# load the data from the last 7 college basketball seasons
filenames = [str(yr)+'_game_scores.csv' for yr in range(2009,2016)]
frames  = [get_data('data/'+f) for f in filenames]

# index the full dataframe by the filename where the raw data came from
data_full = pd.concat(frames, keys=filenames)

# get the names of every team that has a home game in the data
names_full = data_full.groupby('home_name').count().game_ID

# filter out teams with less than 10 home games in the whole dataset
# these will be non-Division I teams
team_list = names_full[names_full>10].index

# we'll fill this with a bunch of dictionaries containing {name, away, home, diff}
ppg_avgs = []

# process each year separately
for f in filenames:
    
    # pull the year off the front of the filename
    year = f[:4]
    
    for team in team_list:
        away_games = data_full.ix[f]['away_name'] == team
        home_games = data_full.ix[f]['home_name'] == team
    
        # compute avg points per game, for home and away games
        away_ppg = data_full.ix[f]['away_final'][away_games].mean()
        home_ppg = data_full.ix[f]['home_final'][home_games].mean()
        
        # compute avg points allowed per game, home and away
        away_papg = data_full.ix[f]['home_final'][away_games].mean()
        home_papg = data_full.ix[f]['away_final'][home_games].mean()
        
        diff_ppg = home_ppg - away_ppg
        diff_papg = home_papg - away_papg
        
        entry = {'year':year, 'team':team, \
                 'away_ppg':away_ppg, 'home_ppg':home_ppg, 'diff_ppg':diff_ppg, \
                 'away_papg':away_papg, 'home_papg':home_papg, 'diff_papg':diff_papg}
        ppg_avgs.append(entry)
        
ppg = pd.DataFrame(ppg_avgs)

# rearrange columns, just for convenience
ppg = ppg[['year', 'team', 'away_ppg', 'home_ppg', 'diff_ppg', \
           'away_papg', 'home_papg', 'diff_papg']].dropna()

sns.distplot(ppg['diff_ppg']);
plt.title('Difference between home and away ppg', fontsize=20, y=1.05);

print('Mean  : ' , ppg.describe()['diff_ppg']['mean'])
print('StdDev: ' , ppg.describe()['diff_ppg']['std'])

# rearrange the data so that it's indexed by team name, and each year's
# diff is in it's own column
pivoted_ppg = ppg.dropna().pivot(index='team', columns='year', values='diff_ppg')
pivoted_papg = ppg.dropna().pivot(index='team', columns='year', values='diff_papg')

# rank each school's diff_ppg and diff_papg, for each year
ranked_ppg = pivoted_ppg.apply(scipy.stats.rankdata, axis=0)
ranked_papg = pivoted_papg.apply(scipy.stats.rankdata, axis=0)

# add column with the average ranking
ranked_ppg['mean'] = ranked_ppg.mean(axis=1)

print(ranked_ppg.sort(columns='mean').head(5))

# helper function to make plots
def make_plots(df, hmap_ax, scat_ax, year1='2015', year2='2014'):
    # plot a correlation matrix of the yearly rankings
    sns.heatmap(df.corr(method='spearman'), annot=True, ax=hmap_ax, vmin=0, vmax=1)

    # plot (year1 rank) vs (year2 rank) for each team
    xs = scipy.stats.rankdata(df[year1].values)
    ys = scipy.stats.rankdata(df[year2].values)
    scat_ax.scatter(xs,ys);
    scat_ax.set_xlabel(year1 + ' rank');
    scat_ax.set_ylabel(year2 + ' rank');


fig, [ax1, ax2] = plt.subplots(1,2, figsize=(16,6))
make_plots(pivoted_ppg, ax1, ax2)

# we'll use this to look up the avg away ppg and papg for each team
grouped_ppg = ppg.groupby(['year','team']).first()

# we'll fill this with a bunch of dictionaries containing {name, away, home, diff}
diffs = []

# helper function to get difference in ppg or papg
def get_diff(opp, year, get='ppg'):
    
    assert get in ['ppg','papg']
    opp_games = data_full.ix[f]['away_name'] == opp
        
    if get == 'ppg':            
        # note: may return more than one value if the teams played more than once
        opp_this = data_full.ix[f][home_games & opp_games]['away_final'].values
        opp_avg = grouped_ppg.ix[year,opp]['away_ppg']
                
    elif get == 'papg':
        # note: may return more than one value if the teams played more than once
        opp_this = data_full.ix[f][home_games & opp_games]['home_final'].values
        opp_avg = grouped_ppg.ix[year,opp]['away_papg']
        
    d = opp_this - opp_avg
                
    # note: if d has two entries the second entry almost certainly
    # refers to a game played at a neutral site. Teams never play
    # each other twice at one team's home court
    return d.tolist()[0]


# process each year separately
for f in filenames:
    
    # pull the year off the front of the filename
    year = f[:4]
    
    for team in team_list:
        home_games = data_full.ix[f]['home_name'] == team
        home_opponents = data_full.ix[f]['away_name'][home_games].values
        
        def_diffs = []
        off_diffs = []
        
        # for each opponent, take the difference of season average
        # ppg / papg (away games) and the points scored / allowed against this team
        for opp in set(home_opponents):
            try:
                def_diffs.append(get_diff(opp, year, 'ppg'))
                off_diffs.append(get_diff(opp, year, 'papg'))
            
            # for named non-DI schools that show up in the opponents list
            except KeyError:
                pass

        entry = {'year':year, 'team':team, \
                 'def_adv':np.mean(def_diffs),'off_adv':np.mean(off_diffs)}
        diffs.append(entry)
 
# the advantage column gives the factor by which the opposing teams score is 
# adjusted by playing here, i.e. -8 means teams score 8 fewer points on average
# at this arena
hca = pd.DataFrame(diffs)

pivoted_hca_ppg = hca.pivot(index='team', columns='year', values='def_adv').dropna()
pivoted_hca_papg = hca.pivot(index='team', columns='year', values='off_adv').dropna()

fig, [[ax1, ax2], [ax3, ax4]] = plt.subplots(2,2, figsize=(16,12));

ax1.set_title('Visiting team PPG vs away avg', fontsize=20, y = 1.05);
ax3.set_title('Visiting team PAPG vs away avg', fontsize=20, y = 1.05);

make_plots(pivoted_hca_ppg, ax1, ax2)
make_plots(pivoted_hca_papg, ax3, ax4)

fig.tight_layout()

# rank the effect on home team PPG/PAPG for each year
ranked_ppg = pivoted_ppg.apply(scipy.stats.rankdata, axis=0)
ranked_papg = pivoted_papg.apply(scipy.stats.rankdata, axis=0)

# rank the effect on visiting PPG/PAPG for each year
ranked_hca_ppg = pivoted_hca_ppg.apply(scipy.stats.rankdata, axis=0)
ranked_hca_papg = pivoted_hca_papg.apply(scipy.stats.rankdata, axis=0)

# reverse the ordering of the PAPG stats, since 'good' values are 
# the opposite sign as 'good' PPG stats
ranked_hca_papg = ranked_hca_papg.apply(lambda col: (1 + len(col)) - col, axis=0)
ranked_papg = ranked_papg.apply(lambda col: (1 + len(col)) - col, axis=0)

# put all the rankings into the same dataframe,
# note: will result in duplicate column names
all_ranks = pd.concat((ranked_hca_papg, ranked_hca_ppg, ranked_ppg, ranked_papg), axis=1)

# group over the duplicate column names, i.e compute average 
# of the four rankings for each year
avg_ranks = all_ranks.groupby(level=0, axis=1).mean()

sns.heatmap(avg_ranks.corr(method='spearman'), annot=True, vmin=0, vmax=1);

# average the rankings accross all seasons
final_list = pd.DataFrame(avg_ranks.mean(axis=1))

# rank the teams 
final_list['rank'] = scipy.stats.rankdata(final_list)

# cue the debate
print(final_list.sort('rank')['rank'].head(15))