
import copy
import matplotlib.patches as mpatches
from matplotlib import pyplot as plt
import numpy as np
import os
import pandas as pd
import seaborn as sns
from sklearn import linear_model
from sklearn.metrics import mean_squared_error, r2_score
import warnings
warnings.filterwarnings('ignore')


#will contain the dataframes of the data from the csv files
stats = dict()

#find the current working directory, used in reading the csv files
cwd = os.getcwd()

#reading the csv files into dataframes and adding them to the stats dictionary
for i in range(2015,2021):
    stats[i] = []
    stats[i].append(pd.read_csv(cwd + "/" + str(i) + "/Fantrax-Players-We Love Sabermetrics.csv"))
    for j in range(1,3):
        file =  cwd + "/" + str(i) + "/Fantrax-Players-We Love Sabermetrics (" + str(j) + ").csv"
        stats[i].append(pd.read_csv(file))

#all years of the data, for each category (Tracked, Extra, Sabermetric), we have many of the
#exact same columns names. We want to remove duplicate columns and the following dropi variables
#contain the columns to be dropped.
drop1 = ((set(stats[2020][0].columns) & set(stats[2020][1].columns)) |
         (set(stats[2020][1].columns) & set(stats[2020][2].columns))).difference(['Player','FPts'])

drop2 = ((set(stats[2020][0].columns) & set(stats[2020][2].columns)) |
         (set(stats[2020][1].columns) & set(stats[2020][2].columns))).difference(['Player','FPts'])

#dropping duplicate columns and merging the batters data together, leaving
#one dataframe for batters for each year 2015-2020.
def convert_to_float(df,column):
    df[column] = df[column].apply(lambda x : float(x))

def convert_to_int(df,column):
    df[column] = df[column].apply(lambda x : int(x))

#dropping the columns that are not needed
for key in stats.keys():
    for i in range(3):
        if i == 1:
            stats[key][i].drop(drop1,axis=1,inplace=True)
        elif i == 2:
            stats[key][i].drop(drop2,axis=1,inplace=True)
        else:
            stats[key][i].drop(["Opponent","Team"],axis=1,inplace=True)
    batters = stats[key][0].merge(stats[key][1],on=['Player','FPts']).merge(stats[key][2],on=['Player','FPts'])
    stats[key] = batters


stats_to_int = ['Rk', 'Age', 'GP', 'AB', 'R', 'H', '2B', '3B', 'HR', 'RBI', 'BB',
                'SO', 'SB', 'CS', 'RC', 'TB', 'XBH', 'PA', 'year']
stats_to_float = ['FP/G', 'FPts','AVG', 'OBP', 'SLG', 'OPS', 'BB/PA', 'K/PA', 'ISO', 'BABIP', 'WOBA']

#creating the years column and filtering out batters who do not have enough at-bats
for i in range(2015,2021):
    if i == 2020:
        stats[2020] = stats[2020][stats[2020]['AB'] >= 50]
    else:
        stats[i] = stats[i][stats[i]['AB'] >= 125]
    stats[i]['year'] = i
    stats[i]['year'] = i

#age is initially constant for a player regardless of year, so that is fixed here
for year in range(2015,2020):
    stats[year]['Age'] = stats[year]['Age'] - (2020 - year)

#deep copies and appends each dataframe in a dictionary of dataframes
def get_all_bp(players_data, start_year=2015,end_year=2021):
    all_data = copy.deepcopy(players_data[start_year])
    for year in range(start_year + 1, end_year):
        all_data = all_data.append(copy.deepcopy(players_data[year]),ignore_index=True)
    return all_data

#combining the stats of all batters into 1 dataframe and removing more not needed columns
all_batters = get_all_bp(stats)
for stat in stats_to_int:
    convert_to_int(all_batters,stat)

for stat in stats_to_float:
    convert_to_float(all_batters,stat)

all_batters.drop(['CYC','Sl','GIDP','SF','SH','IBB','HBP','Status'],axis=1,inplace=True)


ppg_batters = all_batters['FP/G']

#creating the distribution
plt.figure(figsize=(8,6))
plt.hist(ppg_batters,bins = 50)
plt.xlabel('Fantasy Points Per Game')
plt.ylabel('Number of Players')
plt.title('Fantasy Points Per Game for Batters')

plt.show()


batters_ab = all_batters['AB']
batters_gp = all_batters['GP']

#creating the scatter plots
fig, ax = plt.subplots(1, 2,figsize=(15,8))
ax[0].scatter(batters_gp,ppg_batters)
ax[0].set_xlabel('Games Played')
ax[0].set_ylabel('Fantasy Points Per Game')
ax[0].set_title('FP/G v. GP for Batters')

ax[1].scatter(batters_ab,ppg_batters)
ax[1].set_xlabel('At Bats')
ax[1].set_ylabel('Fantasy Points Per Game')
ax[1].set_title('FP/G v. AB for Batters')

plt.show()


age2029 = all_batters[(all_batters['Age'] <= 29)]
age3039 = all_batters[(all_batters['Age'] > 29)]

fig, ax = plt.subplots(2,1,figsize=(15,10))
sns.violinplot(data=age2029,x='Age',y='FP/G',ax=ax[0])
sns.violinplot(data=age3039,x='Age',y='FP/G',ax=ax[1])

ax[0].set_title('FP/G distributions by Age for ages 20-29')
ax[1].set_title('FP/G distributions by Age for ages 30-40')
plt.show()


std_batters = copy.deepcopy(all_batters)
std_batters = std_batters[['Player','year','H','R','HR','RBI','FP/G']]

#finds the mean value of a column (column) in a dataframe (df), given the row's (row) year
def mean_column(df,row,column):
    return dict(df.groupby('year')[column].mean())[row['year']]

#finds the standard deviation of a column (column) in a dataframe (df), given the row's (row) year
def std_column(df,row,column):
    return dict(df.groupby('year').column.std())[row['year']]

#standardizing the ['H','R','HR','RBI','FP/G'] columns
for stat in ['H','R','HR','RBI','FP/G']:
    std_batters['mean' + stat] = std_batters.apply(lambda row : mean_column(std_batters,row,stat),axis=1)
    std_batters['std' + stat] = std_batters.apply(lambda row : mean_column(std_batters,row,stat),axis=1)
    std_batters[stat + "z" ] = (std_batters[stat] - std_batters['mean' + stat]) / std_batters['std' + stat]

fig, ax = plt.subplots(2,2,figsize=(15,10))
ax[0][0].scatter(std_batters['Hz'],std_batters['FP/G'])
ax[0][0].set_title('FP/G v. H')
ax[0][0].set_xlabel('Standardized H')
ax[0][0].set_ylabel('Points Per Game')

ax[0][1].scatter(std_batters['HRz'],std_batters['FP/G'])
ax[0][1].set_title('FP/G v. HR')
ax[0][1].set_xlabel('Standardized HR')
ax[0][1].set_ylabel('Points Per Game')

ax[1][0].scatter(std_batters['Rz'],std_batters['FP/G'])
ax[1][0].set_title('FP/G v. R')
ax[1][0].set_xlabel('Standardized R')
ax[1][0].set_ylabel('Points Per Game')

ax[1][1].scatter(std_batters['RBIz'],std_batters['FP/G'])
ax[1][1].set_title('FP/G v. RBI')
ax[1][1].set_xlabel('Standardized RBI')
ax[1][1].set_ylabel('Points Per Game')

plt.show()


fig = plt.figure(figsize=(15,10))
patches=[]
scoring={'2B' : 2, 'E' : -2, 'HBP' : 0.5, 'HR' : 4, 'RBI' : 1, 'R' : 1, '1B' : 1, '2B' : 2,
         'SO' : -0.5, '3B' : 3, 'BB' : 1,'SB' : 2}
to_plot={'1B':'red','R':'green','2B' : 'blue','3B' : 'orange','HR' : 'yellow','RBI' : 'purple',
         'BB':'pink','SB':'olive'}

mean_batters = all_batters.groupby('year').mean().reset_index()
mean_batters['1B'] = mean_batters['H'] - mean_batters['HR'] - mean_batters['3B'] - mean_batters['2B']
mean_batters = mean_batters[['year','GP','FPts','FP/G','R','1B','2B','3B','HR','RBI','BB','SB']]

for stat in to_plot.keys():
    mean_batters[stat] = mean_batters.apply(lambda row : row[stat]*scoring[stat]/162 if row['year'] != 2020
                                            else row[stat]*scoring[stat]/60, axis = 1)

for stat in to_plot.keys():
    sns.pointplot(x=mean_batters['year'],y=mean_batters[stat],color = to_plot[stat])
    patch = mpatches.Patch(color=to_plot[stat], label=stat)
    patches.append(patch)

plt.legend(handles=patches)
plt.title('Year v. Points Per Game for Traditional Statistics')
plt.xlabel('Year')
plt.ylabel('Points Per Game')
plt.show()


fig, ax = plt.subplots(2,2,figsize=(15,10))

on_base = ['AVG', 'OBP', 'SLG', 'OPS']

for i in range(4):
    ax[int(i/2)][i % 2].scatter(all_batters[on_base[i]],all_batters['FP/G'])
    ax[int(i/2)][i % 2].set_title('FP/G v. ' + on_base[i])
    ax[int(i/2)][i % 2].set_xlabel(on_base[i])
    ax[int(i/2)][i % 2].set_ylabel('FP/G')

plt.show()


advanced_stats = ['BB/PA', 'K/PA', 'ISO', 'BABIP', 'WOBA','RC']

fig, ax = plt.subplots(2,3,figsize=(15,10))

for i in range(6):
    ax[int(i/3)][i % 3].scatter(all_batters[advanced_stats[i]],all_batters['FP/G'])
    ax[int(i/3)][i % 3].set_title('FP/G v. ' + advanced_stats[i])
    ax[int(i/3)][i % 3].set_xlabel(advanced_stats[i])
    ax[int(i/3)][i % 3].set_ylabel('FP/G')

plt.show()


all_batters['RCPA'] = all_batters['RC'] / all_batters['PA']

advanced_stats = ['OPS', 'RCPA']

fig, ax = plt.subplots(1,2,figsize=(15,10))

for i in range(2):
    ax[i].scatter(all_batters[advanced_stats[i]],all_batters['FP/G'])
    ax[i].set_title('FP/G v. ' + advanced_stats[i])
    ax[i].set_xlabel(advanced_stats[i])
    ax[i].set_ylabel('FP/G')

plt.show()


#the list of the sets of variables for predicting points per game
predictors =[['RCPA','RBI','K/PA'], ['OPS','K/PA'], ['WOBA','R'], ['ISO','AVG','RBI'], ['SLG','H'], ['HR','OBP']]

#obtaining the training and testing data
train = all_batters.sample(frac = 0.75, replace = False)
test = all_batters[~all_batters.isin(train)].dropna() #all data in all_batters and not in the training set

#will contain the models
models = []
#contains the measure of success of the models (mse, r^2)
df_list = []
results_df = pd.DataFrame()

#for use in bar graps

for i in range(6):
    model = linear_model.LinearRegression()
    model = model.fit(train[predictors[i]],train['FP/G'])
    predictions = model.predict(test[predictors[i]])
    r2 = r2_score(test['FP/G'], predictions)
    mse = mean_squared_error(test['FP/G'],predictions)

    models.append(model)
    models.append(predictions)

    model_name = "Model " + str(i + 1)
    df_list.append({'Model_Name' : model_name, 'r2' : r2, 'mse' : mse})

results_df = pd.DataFrame(df_list)
fig, ax = plt.subplots(1,2,figsize=(20,10))
plot1 = sns.barplot(x='Model_Name',y='r2',data=results_df,ax=ax[0])
ax[0].set_title('R^2 Score for the Different Models',fontsize=20)
ax[0].set_xlabel('Model',fontsize=16)
ax[0].set_ylabel('R^2 Score',fontsize=16)

plot2 = sns.barplot(x='Model_Name',y='mse',data=results_df,ax=ax[1])
ax[1].set_title('MSE Score for the Different Models',fontsize=20)
ax[1].set_xlabel('Model',fontsize=16)
ax[1].set_ylabel('MSE Score',fontsize=16)

plot_lst = [plot1,plot2]

for plot in plot_lst:
    for p in plot.patches:
        plot.annotate(format(p.get_height(), '.3f'),
                       (p.get_x() + p.get_width() / 2., p.get_height()),
                       ha = 'center', va = 'center',
                       xytext = (0, 9),
                       textcoords = 'offset points')
plt.show()


print("Model 1")
print("Model 1 predictors:",predictors[0])
print("Model 1 Coefficients:", models[0].coef_)
print("Model 1 Intercept",models[0].intercept_)
print()
print("Model 3")
print("Model 3 predictors:",predictors[2])
print("Model 3 Coefficients:", models[2].coef_)
print("Model 3 Intercept",models[2].intercept_)

Model 1
Model 1 predictors: ['RCPA', 'RBI', 'K/PA']
Model 1 Coefficients: [ 1.41146950e+01  8.00751830e-03 -1.46835067e+00]
Model 1 Intercept 0.4814960656851932

Model 3
Model 3 predictors: ['WOBA', 'R']
Model 3 Coefficients: [ 5.52038912 -1.77312415]
Model 3 Intercept -1.5223788815094408

Scoring Group	Scoring Category	Points
Hitting	Doubles (2B)	2
Hitting	Errors (E)	-2
Hitting	Hit By Pitches (HBP)	0.5
Hitting	Home Runs (HR)	4
Hitting	Runs Batted In (RBI)	1
Hitting	Runs Scored (R)	1
Hitting	Singles (1B)	1
Hitting	Stolen Bases (2B)	2
Hitting	Strikeouts (SO)	-0.5
Hitting	Triples (3B)	3
Hitting	Walks (BB)	1

Predicting an MLB Player's Performance In Fantasy Baseball

Introduction

Points System

Python Libraries Used

Data Import and Processing

Exploratory Data Analysis

Predicting Batter Performance

Conclusion

Final Remarks and Additional Reads