def get_means_and_stds():
_, _, X_train = input_to_onehot("automagic")
mean1 = np.mean(X_train[:, -1], axis=0)
std1 = np.std(X_train[:, -1], axis=0)
mean2 = np.mean(X_train[:, -2], axis=0)
std2 = np.std(X_train[:, -2], axis=0)
return mean1, std1, mean2, std2
def train():
"""
Performs training and evaluation of MLP model.
TODO:
Implement training and evaluation of MLP model. Evaluate your model on the whole test set each eval_freq iterations.
"""
# Set the random seeds for reproducibility
# np.random.seed(42)
if torch.cuda.is_available():
device = torch.device('cuda')
print("cuda")
else:
device = torch.device('cpu')
script_directory = os.path.split(os.path.abspath(__file__))[0]
filepath = 'grubbyStar4L4W.model'
model_to_train = os.path.join(script_directory,
filepath) # EXCEPT CROSS ENTROPY!
validation_games = 80
onehot_input, y, _ = input_to_onehot('gaussianPredictions')
val_ids = np.random.choice(onehot_input.shape[0],
size=validation_games,
replace=False)
train_ids = [i for i in range(onehot_input.shape[0]) if i not in val_ids]
X_train = onehot_input[train_ids, :]
y_train = y[train_ids]
# X_train = onehot_input[0: -validation_games, :]
# y_train = y[0: -validation_games]
print("X train")
print(X_train.shape)
print(y_train.shape)
X_test = onehot_input[val_ids, :]
y_test = y[val_ids]
# X_test = onehot_input[-validation_games:, :]
# y_test = y[-validation_games:]
print("X test")
print(X_test.shape)
print(y_test.shape)
print(onehot_input.shape)
print(onehot_input.shape[1])
model = GStar4L4WNet(onehot_input.shape[1])
print(model)
optimizer = torch.optim.SGD(model.parameters(),
lr=LEARNING_RATE_DEFAULT,
momentum=0.9,
weight_decay=1e-5)
accuracies = []
losses = []
vag_losses = []
max_acc = 0
min_loss = 1000
vag_games = get_validation_ids()
vag_games = np.array(vag_games)
vag_ids = vag_games[-200:]
vag_input = onehot_input[vag_ids, :]
vag_targets = y[vag_ids]
for epoch in range(1):
val_ids = [
i for i in range(onehot_input.shape[0] -
validation_games, onehot_input.shape[0])
]
val_ids = np.append(val_ids, vag_ids)
val_ids = np.unique(val_ids)
val_ids = np.array(val_ids)
print(len(val_ids), "val ids")
print(val_ids)
train_ids = [
i for i in range(onehot_input.shape[0]) if i not in val_ids
]
X_train = onehot_input[train_ids, :]
y_train = y[train_ids]
X_test = onehot_input[val_ids, :]
y_test = y[val_ids]
print("epoch " + str(epoch))
for iteration in range(MAX_STEPS_DEFAULT):
BATCH_SIZE_DEFAULT = 32
if iteration % 50000 == 0:
print("iteration: " + str(iteration))
model.train()
ids = np.random.choice(X_train.shape[0],
size=BATCH_SIZE_DEFAULT,
replace=False)
X_train_batch = X_train[ids, :]
y_train_batch = y_train[ids]
X_train_batch = np.reshape(X_train_batch, (BATCH_SIZE_DEFAULT, -1))
X_train_batch = Variable(torch.FloatTensor(X_train_batch))
output = model.forward(X_train_batch)
y_train_batch = np.reshape(y_train_batch, (BATCH_SIZE_DEFAULT, -1))
y_train_batch = Variable(torch.FloatTensor(y_train_batch))
loss = center_my_loss(output, y_train_batch)
model.zero_grad()
loss.backward(retain_graph=True)
optimizer.step()
if iteration % EVAL_FREQ_DEFAULT == 0:
model.eval()
ids = np.array(range(len(X_test)))
x = X_test[ids, :]
targets = y_test[ids]
x = np.reshape(x, (len(X_test), -1))
x = Variable(torch.FloatTensor(x))
pred = model.forward(x)
acc = accuracy(pred, targets)
targets = np.reshape(targets, (len(X_test), -1))
targets = Variable(torch.FloatTensor(targets))
calc_loss = center_my_loss(pred, targets)
accuracies.append(acc)
losses.append(calc_loss.item())
###################
if min_loss > calc_loss.item():
min_loss = calc_loss.item()
torch.save(model, model_to_train)
ids = np.array(range(len(X_train)))
x = X_train[ids, :]
targets = y_train[ids]
x = np.reshape(x, (len(X_train), -1))
x = Variable(torch.FloatTensor(x))
pred = model.forward(x)
train_acc = accuracy(pred, targets)
targets = np.reshape(targets, (len(X_train), -1))
targets = Variable(torch.FloatTensor(targets))
train_loss = center_my_loss(pred, targets)
print("iteration: " + str(iteration) + " train acc " +
str(train_acc) + " val acc " + str(acc) +
" train loss " + str(train_loss.item()) +
" val loss " + str(calc_loss.item()))
#torch.save(model, model_to_train)
test_nn.test_all(model_to_train)
print(model_to_train)
print("maxx acc")
print(max_acc)
plt.plot(accuracies)
plt.ylabel('accuracies')
plt.show()
plt.plot(vag_losses, 'r')
plt.plot(losses, 'b')
plt.ylabel('losses')
plt.show()
def load_models(onehot_encoded):
filepath = 'models\\'
script_directory = os.path.split(os.path.abspath(__file__))[0]
grubby_star = os.path.join(script_directory, filepath + 'grubbyStar/grubbyStar.model')
grubby_star2 = os.path.join(script_directory, filepath + 'grubbyStar2/grubbyStar2.model')
grubby_star_3L3W = os.path.join(script_directory, filepath + 'grubbyStar3L-3W/grubbyStar3L-3W.model')
grubby_star_4L3W = os.path.join(script_directory, filepath + 'grubbyStar4L-3W/grubbyStar4L-3W.model')
grubby_star_4L4W = os.path.join(script_directory, filepath + 'grubbyStar4L4W/grubbyStar4L4W.model')
grubby_star_cross_entropy = os.path.join(script_directory, filepath + 'cross_entropy/grubbyStarCrossEntropy.model')
grubby_ce2 = os.path.join(script_directory, filepath + 'cross_entropy/grubbyStarCE2.model')
grubby_ce3 = os.path.join(script_directory, filepath + 'cross_entropy/grubbyStarCE3.model')
grubby_ce4 = os.path.join(script_directory, filepath + 'cross_entropy/grubbyStarCE4.model')
metamodel = os.path.join(script_directory, "metamodel/" + 'grubbyStarMeta.model')
sigmamodel = os.path.join(script_directory, "sigma_metamodel/" + 'grubbyStarSigma.model')
enhanced = os.path.join(script_directory, filepath + "enhanced_features/" + 'enhancedStar.model')
onehot_neural = copy.deepcopy(onehot_encoded)
_, _, X_train = input_to_onehot('automagic')
mean1, std1, mean2, std2 = get_means_and_stds(X_train)
x = standardize_instance(onehot_neural, mean1, std1, mean2, std2)
onehot_neural_cross = copy.deepcopy(onehot_encoded)
_, _, X_train_cross = cross_entropy_input_to_onehot()
mean1_cross, std1_cross, mean2_cross, std2_cross = get_means_and_stds(X_train_cross)
x_cross = standardize_instance(onehot_neural_cross, mean1_cross, std1_cross, mean2_cross, std2_cross)
# input->2, 2->2, 2->1
model = torch.load(grubby_star)
model.eval()
pred = model.forward(x)
neural_pred = pred.detach().numpy()
# input->3, 3->3, 3->1
model2 = torch.load(grubby_star2)
model2.eval()
pred2 = model2.forward(x)
neural_pred2 = pred2.detach().numpy()
# input->3, 3->3, 3->3, 3->1
model3L3W = torch.load(grubby_star_3L3W)
model3L3W.eval()
pred3L3W = model3L3W.forward(x)
neural_pred3L3W = pred3L3W.detach().numpy()
# input->3, 3->3, 3->3, 3->3, 3->1
model4L3W = torch.load(grubby_star_4L3W)
model4L3W.eval()
pred4L3W = model4L3W.forward(x)
neural_pred4L3W = pred4L3W.detach().numpy()
# input->4, 4->4, 4->1
model4L4W = torch.load(grubby_star_4L4W)
model4L4W.eval()
pred4L4W = model4L4W.forward(x)
neural_pred4L4W = pred4L4W.detach().numpy()
######### CROSS ##################
modelCross = torch.load(grubby_star_cross_entropy)
modelCross.eval()
predCross = modelCross.forward(x)
neural_predCross = predCross.detach().numpy()
modelCE2 = torch.load(grubby_ce2)
modelCE2.eval()
predCross2 = modelCE2.forward(x)
neural_predCross2 = predCross2.detach().numpy()
modelCE3 = torch.load(grubby_ce3)
modelCE3.eval()
predCross3 = modelCE3.forward(x)
neural_predCross3 = predCross3.detach().numpy()
modelCE4 = torch.load(grubby_ce4)
modelCE4.eval()
predCross4 = modelCE4.forward(x)
neural_predCross4 = predCross4.detach().numpy()
# print("prediction", pred)
# print("x.shape", x.shape)
# print("pred.shape", pred.shape)
third_tensor = torch.cat((x, pred2), 1)
third_tensor = torch.cat((third_tensor, pred4L3W), 1)
# third_tensor = torch.cat((third_tensor, pred3L3W), 1)
# third_tensor = torch.cat((third_tensor, pred4L3W), 1)
# third_tensor = torch.cat((third_tensor, pred4L4W), 1)
third_tensor = torch.cat((third_tensor, predCross), 1)
# third_tensor = torch.cat((third_tensor, predCross2), 1)
third_tensor = torch.cat((third_tensor, predCross3), 1)
# third_tensor = torch.cat((third_tensor, predCross4), 1)
metaStar = torch.load(metamodel)
metaStar.eval()
pred_meta = metaStar.forward(third_tensor)
coeffs = pred_meta.detach().numpy()
third_tensor = torch.narrow(third_tensor, 1, 25, 4)
result = torch.mul(third_tensor, pred_meta)
result = torch.sum(result, dim=1)
neural_meta = result.detach().numpy()
sigma_tensor = torch.cat((x, pred), 1)
sigma_tensor = torch.cat((sigma_tensor, pred2), 1)
sigma_tensor = torch.cat((sigma_tensor, pred3L3W), 1)
sigma_tensor = torch.cat((sigma_tensor, pred4L3W), 1)
sigma_tensor = torch.cat((sigma_tensor, pred4L4W), 1)
sigma_tensor = torch.cat((sigma_tensor, predCross), 1)
sigma_tensor = torch.cat((sigma_tensor, predCross2), 1)
sigma_tensor = torch.cat((sigma_tensor, predCross3), 1)
sigma_tensor = torch.cat((sigma_tensor, predCross4), 1)
sigmaStar = torch.load(sigmamodel)
sigmaStar.eval()
pred_sigma = sigmaStar.forward(sigma_tensor)
train = torch.narrow(sigma_tensor, 1, 25, 9)
mean = torch.mean(train, dim=1)
s = torch.std(train, dim=1)
result_sigma = mean + torch.mul(torch.transpose(pred_sigma, 0, 1), s)
result_sigma = result_sigma.detach().numpy()
enhancedStar = torch.load(enhanced)
enhancedStar.eval()
pred_enha = enhancedStar.forward(sigma_tensor)
pred_enha = pred_enha.detach().numpy()
return neural_pred, neural_pred2, neural_pred3L3W, neural_pred4L3W, \
neural_pred4L4W, neural_predCross, neural_predCross2, neural_predCross3, neural_predCross4, neural_meta, coeffs[0], result_sigma[0], pred_enha