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()
BALANCED = 468
STRONG_LONG_NO_BALANCED = 530
FIXED_INPUT = 563
STOP_RF_FROM_OVERFITTING = 641
LOGISTIC_MU_CV = 676
NO_HERO = 924
LAST_TRAINED = 1009
LIMIT = 434
UPPER_LIMIT = 3000
opp = 9
graph_a = 20
graph_b = 21
vag_ids = get_validation_ids()
vag_ids = vag_ids[-200:]
validation_games = 100
val_ids = [i for i in range(len(contents) - validation_games, len(contents))]
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)
#val_ids = list(range(LIMIT, UPPER_LIMIT))
def calc_scores_vs_opponent(opponent, cap=95):
scores_vs_opponent = n_predictions * [0]