NNBclf = RNBA.Refridgerator(num_players=3, num_games=4)
NNBclf.Build_Dataset(player_path, Normalized=True)
X_train_NNB, Y_train_NNB, X_dev_NNB, Y_dev_NNB, X_test_NNB, Y_test_NNB = NNBclf.Binary_Clf_Dataset(
normalized=True)
#Train Models
QDA = QuadraticDiscriminantAnalysis()
QDA.fit(X_train_QDA, Y_train_QDA.ravel())
SVM = SVC(kernel='linear')
SVM.fit(X_train_SVM, Y_train_SVM.ravel())
LR = LogisticRegression()
LR.fit(X_train_LR, Y_train_LR.ravel())
NNE = NeuralNetwork.FCNN(6, [6,5,5,"f",5,5,1], "ExpTest", num_epochs = 400, output_layer = "exponential",\
Type = "forked", Regularized = None)
Y_te1, Y_te2 = NNEclf.Forked(Y_train_NNE)
Y_tee1, Y_tee2 = NNEclf.Forked(Y_test_NNE)
modelE = NNE.Model(X_train_NNE, Y_te1, Y_te2)
Loss_test_NNE, pred_test_NNE = NNE.predict(modelE, X_test_NNE,
[Y_tee1, Y_tee2])
Y_ptest_NNE = NNEclf.UnFork(pred_test_NNE)
NNEOutAccte = NNEclf.OutcomeAccuracy(Y_ptest_NNE, Y_test_NNE)
K.clear_session()
NNS = NeuralNetwork.FCNN(9, [200,100,50,20,10,5,"f",5,5,149-58+1], "SoftTest", num_epochs = 400, output_layer = "softmax",\
Type = "forked", Regularized = None)
Y_ts1, Y_ts2 = NNSclf.ToSoftmax(Y_train_NNS, 58, 149)
Y_tes1, Y_tes2 = NNSclf.ToSoftmax(Y_test_NNS, 58, 149)
modelS = NNS.Model(X_train_NNS, Y_ts1, Y_ts2)
Loss_test_NNS, pred_test_NNS = NNS.predict(modelS, X_test_NNS,
import RNBA
import NeuralNetwork
import numpy as np
if __name__ == '__main__':
player_path = 'nba-enhanced-stats/2012-18_playerBoxScore.csv'
clf = RNBA.Refridgerator(num_players=5, num_games=5)
clf.Build_Dataset(player_path, Normalized=True)
X_train, Y_train, X_dev, Y_dev, X_test, Y_test = clf.Read_Dataset(
Normalized=True)
print(np.max(Y_train), np.max(Y_dev), np.max(Y_test))
NN1 = NeuralNetwork.FCNN(7, [60, 50, 40, 30, 20, 10, 2],
"NN_7L_60_50_40_30_20_10_1",
num_epochs=300)
model1 = NN1.Model(X_train, Y_train)
MSE1, predictions1 = NN1.predict(model1, X_dev, Y_dev)
acc = clf.OutcomeAccuracy(predictions1, Y_dev)
print(acc)
X_train_n, Y_train_n = clf.OnePerEx(X_train, Y_train)
X_dev_n, Y_dev_n = clf.OnePerEx(X_dev, Y_dev)
NN = NeuralNetwork.FCNN(7, [60, 50, 40, 30, 20, 10, 1],
"NN_7L_60_50_40_30_20_10_1",
num_epochs=300)
model = NN.Model(X_train_n, Y_train_n)
MSEt, predictionst = NN.predict(model, X_train_n, Y_train_n)
MSE, predictions = NN.predict(model, X_dev_n, Y_dev_n)
acct = clf.OutcomeAccuracy(predictionst, Y_train_n, OnePer=True)
(9, [200, 100, 50, 20, 10, 5, "f", 5, 5, 149-58+1], "NNF_10L_5x5_f_5x4_149_58_sftmx", "forked", "softmax", None),
#(4, [2,5,5,1], "NNS_6L_5x5_1_sig", "stacked", "sigmoid", "L2")]
(4, [2,5,5,1], "NNS_6L_5x5_1_sig", "stacked", "sigmoid", None)]
for i in [0]: #range(2):
OutAccd = np.zeros((10, 10))
OutAcct = np.zeros((10, 10))
for j in range(10): #[1,5,9]:#range(1):
for k in range(10): #[1,5,9]:#range(1):
clf = RNBA.Refridgerator(num_players=num_players[j],
num_games=num_games[k])
clf.Build_Dataset(player_path, Normalized=True)
X_train, Y_train, X_dev, Y_dev, X_test, Y_test = clf.Read_Dataset(
Normalized=True)
NN = NeuralNetwork.FCNN(models[i][0], models[i][1], models[i][2], num_epochs = 400, output_layer = models[i][4],\
Type = models[i][3], Regularized = models[i][5])
if models[i][3] == "forked" and models[i][4] == "exponential":
Y_t1, Y_t2 = clf.Forked(Y_train)
Y_d1, Y_d2 = clf.Forked(Y_dev)
if models[i][3] == "forked" and models[i][4] == "softmax":
Y_t1, Y_t2 = clf.ToSoftmax(Y_train, 58, 149)
Y_d1, Y_d2 = clf.ToSoftmax(Y_dev, 58, 149)
if models[i][4] == "sigmoid":
_, Y_tb, _, Y_db, _, Y_teb = clf.Binary_Clf_Dataset(
normalized=True)
if models[i][3] == "forked":
model = NN.Model(X_train, Y_t1, Y_t2)
Loss_train, predictions_train = NN.predict(
model, X_train, [Y_t1, Y_t2])
elif models[i][3] == "stacked":
model = NN.Model(X_train, Y_tb)
