I have a machine learning model to pick different outcome of each game for a college basketball game.
The X values are:
Feature Range
Money Line -100000 - +9000
Money Line % 0.01 - 0.99
Money Line $ 0.01 - 0.99
Money Line Move -75000 - +66622
Money Line Direction 0 or 1
Spread -45.5 - +45.5
the Y (target) variable is either 0 or 1
My first question is should I normalize the X values? Since the classifiers target value is 0 or 1 and the independent variable are much larger or smaller.
My second question is when you normalize your X variables should you normalize them during feature selection, param tuning, and then on your model?
I'm a little unclear on the process of normalizing your data.
I'm using an lightGBM Classifier, a backward elimination feature selection using OLS, and a Randomized Search CV for param tuning.
Here is my feature selection code:
import pandas as pd
import numpy as np
import statsmodels.api as sm
import matplotlib.pyplot as plt
from sklearn.model_selection import StratifiedKFold
training_data = pd.read_csv(
"/Users/aus10/Machine_Learning_Betting/Data/Betting_Data/CBB/Training_Data_Betting_CBB.csv", index_col=False)
df_model = training_data.copy()
df_model = df_model.dropna()
target = 'Cover'
X = df_model.drop(target, axis=1)
X = df_model.iloc[:, 1:18] # independent columns
y = df_model[target] # target column
X_1 = sm.add_constant(X)
model = sm.OLS(y, X_1).fit()
cols = list(X.columns)
pmax = 1
while (len(cols) > 0):
p = []
X_1 = X[cols]
X_1 = sm.add_constant(X_1)
model = sm.OLS(y, X_1).fit()
p = pd.Series(model.pvalues.values[1:], index=cols)
pmax = max(p)
feature_with_p_max = p.idxmax()
if(pmax > 0.05):
cols.remove(feature_with_p_max)
else:
break
selected_features_BE = cols
print(selected_features_BE)
Here is the code to tune the params:
import pandas as pd
import lightgbm as lgb
from sklearn.model_selection import StratifiedKFold, GridSearchCV, RandomizedSearchCV
from scipy.stats import randint as sp_randint
from scipy.stats import uniform as sp_uniform
training_data = pd.read_csv(
'/Users/aus10/Machine_Learning_Betting/Data/Betting_Data/CBB/Training_Data_Betting_CBB.csv')
df_model = training_data.copy()
df_model = df_model.dropna()
# independent columns
X = df_model.loc[:, ['Spread_Move']]
y = df_model['Cover'] # target column
skf = StratifiedKFold(n_splits=2)
skf.get_n_splits(X, y)
StratifiedKFold(n_splits=2, random_state=None, shuffle=False)
for train_index, test_index in skf.split(X, y):
X_train, X_test = X.iloc[train_index], X.iloc[test_index]
y_train, y_test = y.iloc[train_index], y.iloc[test_index]
fit_params = {
'early_stopping_rounds': 30,
'eval_metric': 'auc',
'eval_set': [(X_test, y_test)],
'eval_names': ['valid'],
'verbose': 100,
'categorical_feature': 'auto'
}
param_test = {
'num_leaves': sp_randint(6, 50),
'min_child_samples': sp_randint(100, 500),
'min_child_weight': [1e-5, 1e-3, 1e-2, 1e-1, 1, 1e1, 1e2, 1e3, 1e4],
'subsample': sp_uniform(loc=0.2, scale=0.8),
'colsample_bytree': sp_uniform(loc=0.4, scale=0.6),
'reg_alpha': [0, 1e-1, 1, 2, 5, 7, 10, 50, 100],
'reg_lambda': [0, 1e-1, 1, 5, 10, 20, 50, 100],
'n_estimators': [100, 300, 500, 800, 1200],
'max_depth': [5, 8, 15, 25, 30]
}
n_HP_points_to_test = 100
clf = lgb.LGBMClassifier(random_state=314, silent=True,
metrix='None', n_jobs=-1)
gs = RandomizedSearchCV(
estimator=clf, param_distributions=param_test, n_iter=n_HP_points_to_test, scoring='roc_auc', cv=3, refit=True, random_state=314, verbose=True)
gs.fit(X_train, y_train, **fit_params)
print('\n CBB Spread lgb Best score reached {} with params {} '.format(
gs.best_score_, gs.best_params_))
print()
and finally, here is the model:
import pandas as pd
import lightgbm as lgb
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
import numpy as np
import json
training_data = pd.read_csv(
'/Users/aus10/Machine_Learning_Betting/Data/Betting_Data/CBB/Training_Data_Betting_CBB.csv')
test_data = pd.read_csv(
'/Users/aus10/Machine_Learning_Betting/Data/Betting_Data/CBB/Test_Data_Betting_CBB.csv')
df_model = training_data.copy()
df_model = df_model.dropna()
df_test = test_data.copy()
df_test = df_test.dropna()
df_test = df_test.replace(to_replace='None', value=np.nan).dropna()
# independent columns
X = df_model.loc[:, ['Spread_Move']]
y = df_model['Cover'] # target column
results = []
model = lgb.LGBMClassifier(colsample_bytree=0.6433117836032942, max_depth=30, min_child_samples=114, min_child_weight=100.0,
n_estimators=1200, num_leaves=7, reg_alpha=1, reg_lambda=20, subsample=0.27963305897119684)
model.fit(X, y)
skf = StratifiedKFold(n_splits=2)
skf.get_n_splits(X, y)
StratifiedKFold(n_splits=2, random_state=None, shuffle=False)
for train_index, test_index in skf.split(X, y):
X_train, X_test = X.iloc[train_index], X.iloc[test_index]
y_train, y_test = y.iloc[train_index], y.iloc[test_index]
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print()
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))
print('\n CBB Spread LightGBM {}'.format(
round(accuracy_score(y_test, y_pred), 2)))
index = 0
count = 0
while count < len(df_test):
team = df_test.loc[index].at['Team']
spread_move = df_test.loc[index].at['Spread_Move']
Xnew = [[spread_move]]
# make a prediction
ynew = model.predict_proba(Xnew)
# show the inputs and predicted outputs
results.append(
{
'Team': team,
'Cover': ynew[0][1]
})
index += 1
count += 1
with open('/Users/aus10/Machine_Learning_Betting/Data/ML_Results/CBB/Cover_Probability_LightGBM.json', 'w') as my_file:
json.dump(results, my_file)
