import os
import re
import sklearn
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from collections import Counter
from sklearn.metrics import *
from sklearn.linear_model import *
from sklearn.model_selection import *
from sklearn.svm import SVC
from sklearn.naive_bayes import MultinomialNB
from lightgbm import LGBMClassifier,LGBMRegressor
from sklearn.tree import DecisionTreeClassifier
from sklearn.semi_supervised import LabelSpreading
from catboost import CatBoostClassifier,CatBoostRegressor
pd.set_option('display.max_columns', None)
DATA_PATH = '/work/NCAAMData/'
for filename in os.listdir(DATA_PATH):
print(filename)
df_seeds = pd.read_csv(DATA_PATH + "MNCAATourneySeeds.csv")
# df_seeds = pd.read_csv(DATA_PATH + "WNCAATourneySeeds.csv")
df_seeds.head()
df_season_results = pd.read_csv(DATA_PATH + "MRegularSeasonCompactResults.csv")
# df_season_results = pd.read_csv(DATA_PATH + "WRegularSeasonCompactResults.csv")
df_season_results.drop(['NumOT', 'WLoc'], axis=1, inplace=True)
df_season_results['ScoreGap'] = df_season_results['WScore'] - df_season_results['LScore']
df_season_results.head()
num_win = df_season_results.groupby(['Season', 'WTeamID']).count()
num_win = num_win.reset_index()[['Season', 'WTeamID', 'DayNum']].rename(columns={"DayNum": "NumWins", "WTeamID": "TeamID"})
num_loss = df_season_results.groupby(['Season', 'LTeamID']).count()
num_loss = num_loss.reset_index()[['Season', 'LTeamID', 'DayNum']].rename(columns={"DayNum": "NumLosses", "LTeamID": "TeamID"})
gap_win = df_season_results.groupby(['Season', 'WTeamID']).mean().reset_index()
gap_win = gap_win[['Season', 'WTeamID', 'ScoreGap']].rename(columns={"ScoreGap": "GapWins", "WTeamID": "TeamID"})
gap_loss = df_season_results.groupby(['Season', 'LTeamID']).mean().reset_index()
gap_loss = gap_loss[['Season', 'LTeamID', 'ScoreGap']].rename(columns={"ScoreGap": "GapLosses", "LTeamID": "TeamID"})
df_features_season_w = df_season_results.groupby(['Season', 'WTeamID']).count().reset_index()[['Season', 'WTeamID']].rename(columns={"WTeamID": "TeamID"})
df_features_season_l = df_season_results.groupby(['Season', 'LTeamID']).count().reset_index()[['Season', 'LTeamID']].rename(columns={"LTeamID": "TeamID"})
df_features_season = pd.concat([df_features_season_w, df_features_season_l], 0).drop_duplicates().sort_values(['Season', 'TeamID']).reset_index(drop=True)
df_features_season = df_features_season.merge(num_win, on=['Season', 'TeamID'], how='left')
df_features_season = df_features_season.merge(num_loss, on=['Season', 'TeamID'], how='left')
df_features_season = df_features_season.merge(gap_win, on=['Season', 'TeamID'], how='left')
df_features_season = df_features_season.merge(gap_loss, on=['Season', 'TeamID'], how='left')
rating = pd.read_csv("/work/External Data/538ratingsMen.csv")
df_features_season = df_features_season.merge(rating, on=['Season', 'TeamID'], how='left')
df_features_season.fillna(0, inplace=True)
df_features_season['WinRatio'] = df_features_season['NumWins'] / (df_features_season['NumWins'] + df_features_season['NumLosses'])
df_features_season['GapAvg'] = (
(df_features_season['NumWins'] * df_features_season['GapWins'] -
df_features_season['NumLosses'] * df_features_season['GapLosses'])
/ (df_features_season['NumWins'] + df_features_season['NumLosses'])
)
df_features_season.drop(['NumWins', 'NumLosses', 'GapWins', 'GapLosses'], axis=1, inplace=True)
df_tourney_results = pd.read_csv(DATA_PATH + "MNCAATourneyCompactResults.csv")
# df_tourney_results = pd.read_csv(DATA_PATH + "WNCAATourneyCompactResults.csv")
df_tourney_results.drop(['NumOT', 'WLoc'], axis=1, inplace=True)
def get_round(day):
# round_dic = {134: 0, 135: 0, 136: 1, 137: 1, 138: 2, 139: 2, 143: 3, 144: 3, 145: 4, 146: 4, 152: 5, 154: 6}
round_dic = {137: 0, 138: 0, 139: 1, 140: 1, 141: 2, 144: 3, 145: 3, 146: 4, 147: 4, 148: 4, 151:5, 153: 5, 155: 6} # probably wrong but I don't use it anyways
try:
return round_dic[day]
except:
print(f'Unknow day : {day}')
return 0
df_tourney_results.head()
df = df_tourney_results.copy()
df = df[df['Season'] >= 2003].reset_index(drop=True)
df.head()
df = pd.merge(
df,
df_seeds,
how='left',
left_on=['Season', 'WTeamID'],
right_on=['Season', 'TeamID']
).drop('TeamID', axis=1).rename(columns={'Seed': 'SeedW'})
df = pd.merge(
df,
df_seeds,
how='left',
left_on=['Season', 'LTeamID'],
right_on=['Season', 'TeamID']
).drop('TeamID', axis=1).rename(columns={'Seed': 'SeedL'})
def treat_seed(seed):
return int(re.sub("[^0-9]", "", seed))
df['SeedW'] = df['SeedW'].apply(treat_seed)
df['SeedL'] = df['SeedL'].apply(treat_seed)
df.head()
df = pd.merge(
df,
df_features_season,
how='left',
left_on=['Season', 'WTeamID'],
right_on=['Season', 'TeamID']
).rename(columns={
'NumWins': 'NumWinsW',
'NumLosses': 'NumLossesW',
'GapWins': 'GapWinsW',
'GapLosses': 'GapLossesW',
'WinRatio': 'WinRatioW',
'GapAvg': 'GapAvgW',
}).drop(columns='TeamID', axis=1)
df = pd.merge(
df,
df_features_season,
how='left',
left_on=['Season', 'LTeamID'],
right_on=['Season', 'TeamID']
).rename(columns={
'NumWins': 'NumWinsL',
'NumLosses': 'NumLossesL',
'GapWins': 'GapWinsL',
'GapLosses': 'GapLossesL',
'WinRatio': 'WinRatioL',
'GapAvg': 'GapAvgL',
}).drop(columns='TeamID', axis=1)
df.head()
def add_loosing_matches(win_df):
win_rename = {
"WTeamID": "TeamIdA",
"WScore" : "ScoreA",
"LTeamID" : "TeamIdB",
"LScore": "ScoreB",
"SeedW": "SeedA",
"SeedL": "SeedB",
'WinRatioW' : 'WinRatioA',
'WinRatioL' : 'WinRatioB',
'GapAvgW' : 'GapAvgA',
'GapAvgL' : 'GapAvgB',
# "OrdinalRankW": "OrdinalRankA",
# "OrdinalRankL": "OrdinalRankB",
}
lose_rename = {
"WTeamID": "TeamIdB",
"WScore" : "ScoreB",
"LTeamID" : "TeamIdA",
"LScore": "ScoreA",
"SeedW": "SeedB",
"SeedL": "SeedA",
'GapAvgW' : 'GapAvgB',
'GapAvgL' : 'GapAvgA',
'WinRatioW' : 'WinRatioB',
'WinRatioL' : 'WinRatioA',
# "OrdinalRankW": "OrdinalRankB",
# "OrdinalRankL": "OrdinalRankA",
}
win_df = win_df.copy()
lose_df = win_df.copy()
win_df = win_df.rename(columns=win_rename)
lose_df = lose_df.rename(columns=lose_rename)
return pd.concat([win_df, lose_df], 0, sort=False)
df = add_loosing_matches(df)
df['SeedDiff'] = df['SeedA'] - df['SeedB']
df['ratingDiff'] = df['538rating_x'] - df['538rating_y']
df['WinRatioDiff'] = df['WinRatioA'] - df['WinRatioB']
df['GapAvgDiff'] = df['GapAvgA'] - df['GapAvgB']
# df['OrdinalRankDiff'] = df['OrdinalRankA'] - df['OrdinalRankB']
df.head()
df_test = pd.read_csv(DATA_PATH + "MSampleSubmissionStage2.csv")
# df_test = pd.read_csv(DATA_PATH + "WSampleSubmissionStage1.csv")
df_test['Season'] = df_test['ID'].apply(lambda x: int(x.split('_')[0]))
df_test['TeamIdA'] = df_test['ID'].apply(lambda x: int(x.split('_')[1]))
df_test['TeamIdB'] = df_test['ID'].apply(lambda x: int(x.split('_')[2]))
df_test.head()
df_test = pd.merge(
df_test,
df_seeds,
how='left',
left_on=['Season', 'TeamIdA'],
right_on=['Season', 'TeamID']
).drop('TeamID', axis=1).rename(columns={'Seed': 'SeedA'})
df_test = pd.merge(
df_test,
df_seeds,
how='left',
left_on=['Season', 'TeamIdB'],
right_on=['Season', 'TeamID']
).drop('TeamID', axis=1).rename(columns={'Seed': 'SeedB'})
df_test['SeedA'] = df_test['SeedA'].apply(treat_seed)
df_test['SeedB'] = df_test['SeedB'].apply(treat_seed)
df_test = pd.merge(
df_test,
df_features_season,
how='left',
left_on=['Season', 'TeamIdA'],
right_on=['Season', 'TeamID']
).rename(columns={
'NumWins': 'NumWinsA',
'NumLosses': 'NumLossesA',
'GapWins': 'GapWinsA',
'GapLosses': 'GapLossesA',
'WinRatio': 'WinRatioA',
'GapAvg': 'GapAvgA',
}).drop(columns='TeamID', axis=1)
df_test = pd.merge(
df_test,
df_features_season,
how='left',
left_on=['Season', 'TeamIdB'],
right_on=['Season', 'TeamID']
).rename(columns={
'NumWins': 'NumWinsB',
'NumLosses': 'NumLossesB',
'GapWins': 'GapWinsB',
'GapLosses': 'GapLossesB',
'WinRatio': 'WinRatioB',
'GapAvg': 'GapAvgB',
}).drop(columns='TeamID', axis=1)
# df_test = pd.merge(
# df_test,
# avg_ranking,
# how='left',
# left_on=['Season', 'TeamIdA'],
# right_on=['Season', 'TeamID']
# ).drop('TeamID', axis=1).rename(columns={'OrdinalRank': 'OrdinalRankA'})
# df_test = pd.merge(
# df_test,
# avg_ranking,
# how='left',
# left_on=['Season', 'TeamIdB'],
# right_on=['Season', 'TeamID']
# ).drop('TeamID', axis=1).rename(columns={'OrdinalRank': 'OrdinalRankB'})
df_test['SeedDiff'] = df_test['SeedA'] - df_test['SeedB']
df_test['ratingDiff'] = df_test['538rating_x'] - df_test['538rating_y']
df_test['WinRatioDiff'] = df_test['WinRatioA'] - df_test['WinRatioB']
df_test['GapAvgDiff'] = df_test['GapAvgA'] - df_test['GapAvgB']
# df_test['OrdinalRankDiff'] = df_test['OrdinalRankA'] - df_test['OrdinalRankB']
df_test.head()
df['ScoreDiff'] = df['ScoreA'] - df['ScoreB']
df['WinA'] = (df['ScoreDiff'] > 0).astype(int)
features = [
'SeedA',
'SeedB',
'WinRatioA',
'GapAvgA',
'WinRatioB',
'GapAvgB',
# 'OrdinalRankA',
# 'OrdinalRankB',
'SeedDiff','538rating_x','538rating_y','ratingDiff',
'WinRatioDiff',
'GapAvgDiff'
# 'OrdinalRankDiff',
]
from sklearn.preprocessing import StandardScaler,MaxAbsScaler,PolynomialFeatures,\
MinMaxScaler
def rescale(features, df_train, df_val, df_test=None):
# min_ = df_train[features].min()
# max_ = df_train[features].max()
scalar= MinMaxScaler()
df_train[features] = scalar.fit_transform(df_train[features])
df_val[features] = scalar.transform(df_val[features])
# df_train[features] = (df_train[features] - min_) / (max_ - min_)
# df_val[features] = (df_val[features] - min_) / (max_ - min_)
if df_test is not None:
# df_test[features] = (df_test[features] - min_) / (max_ - min_)
df_test[features] = scalar.transform(df_test[features])
return df_train, df_val, df_test
def kfold_reg(df, df_test_=None, plot=False, verbose=0, mode="reg"):
seasons = df['Season'].unique()
cvs = []
pred_tests = []
target = "ScoreDiff" if mode == "reg" else "WinA"
for season in seasons[13:]:
if verbose:
print(f'\nValidating on season {season}')
df_train = df[df['Season'] < season].reset_index(drop=True).copy()
df_val = df[df['Season'] == season].reset_index(drop=True).copy()
df_test = df_test_.copy()
df_train, df_val, df_test = rescale(features, df_train, df_val, df_test)
if mode == "reg":
# model = ElasticNet(alpha=1, l1_ratio=0.5)
model = CatBoostRegressor(iterations=200,od_type="Iter",l2_leaf_reg=3,
learning_rate=0.3,
depth=13,verbose=0)
# model = LGBMRegressor(learning_rate=0.001, n_estimators=2000,
# random_state=33)
elif mode == "lgbm":
model = LGBMClassifier(learning_rate=0.005, n_estimators=1000, num_leaves=32,
random_state=33)
elif mode == "nb":
model = MultinomialNB(alpha=0.5)
elif mode == "cat":
model = CatBoostClassifier(iterations=100,od_type="Iter",l2_leaf_reg=5,
learning_rate=0.3,
depth=13,verbose=0)
elif mode == "ls":
model = LabelSpreading(kernel='rbf',n_neighbors=8,alpha=0.01,max_iter=500,tol=0.003)
else:
model = LogisticRegression(C=10)
model.fit(df_train[features], df_train[target])
if mode == "reg":
pred = model.predict(df_val[features])
# pred = (pred - pred.min()) / (pred.max() - pred.min())
else:
pred = model.predict_proba(df_val[features])[:, 1]
if df_test is not None:
if mode == "reg":
pred_test = model.predict(df_test[features])
# pred_test = (pred_test - pred_test.min()) / (pred_test.max() - pred_test.min())
else:
pred_test = model.predict_proba(df_test[features])[:, 1]
pred_tests.append(pred_test)
if plot:
plt.figure(figsize=(15, 6))
plt.subplot(1, 2, 1)
plt.scatter(pred, df_val['ScoreDiff'].values, s=5)
plt.grid(True)
plt.subplot(1, 2, 2)
sns.histplot(pred)
plt.show()
loss = log_loss(df_val['WinA'].values, pred)
cvs.append(loss)
if verbose:
print(f'\t -> Scored {loss:.3f}')
print(f'\n Local CV is {np.mean(cvs):.3f}')
return pred_tests
pred_tests = kfold_reg(df, df_test, plot=False, verbose=1, mode="reg")
pred_test = np.mean(pred_tests, 0).astype('int')
sub = df_test[['ID', 'Pred']].copy()
sub['Pred'] = pred_test
sub.to_csv('submission.csv', index=False)
_ = sns.histplot(sub['Pred'])
sub.head()
