class BDTTrain:
"""
class structure to train the BDT with a certain embedding.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, bayesian_dim):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = 200 # test on 40, train on 160
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_BDFIL_hetero_deadline_pairwise.pkl'
self.bayesian_embedding_dim = int(bayesian_dim)
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_data(
self.num_schedules, self.data)
self.start_of_each_set_twenty = create_sets_of_20_from_x_for_pairwise_comparisions(
self.schedule_array)
self.embedding_list = [
torch.ones(self.bayesian_embedding_dim) * 1 / 3
for _ in range(self.num_schedules)
]
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
use_gpu = True
self.model = ProLoNet(
input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=16,
output_dim=2,
bayesian_embedding_dim=self.bayesian_embedding_dim,
alpha=1.5,
use_gpu=use_gpu,
vectorized=True,
is_value=False).cuda()
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
# delete embedding parameter
del params[0]
self.opt = torch.optim.RMSprop(params, lr=.0001)
# optimizer for the embedding
self.embedding_optimizer = torch.optim.Adam([{
'params': self.model.bayesian_embedding,
'lr': .01
}])
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 2000
self.distribution_epsilon = .0001
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, produces training data using x_i - x_j
and trains upon that.
:return:
"""
training_done = False
cv_cutoff = .8 * len(self.start_of_each_set_twenty)
loss_func = AlphaLoss()
# variables to keep track of loss and number of tasks trained over
running_loss_predict_tasks = 0
num_iterations_predict_task = 0
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(cv_cutoff)
set_of_twenty = self.start_of_each_set_twenty[
rand_timestep_within_sched]
# truth is the same as the task chosen
# NOTE: if initial truth > 10, it is biggest task first. Else it is smallest task first. Approximate way to keep track of
# the current type of schedule
truth = self.Y[set_of_twenty]
# get the current schedule that the timestep is from
which_schedule = find_which_schedule_this_belongs_to(
self.schedule_array, set_of_twenty)
# load in the embedding from the list into the network
load_in_embedding(self.model, self.embedding_list, which_schedule)
# find feature vector of true action taken
phi_i_num = truth + set_of_twenty
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# transform into torch variables
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
# get model output
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# Updates embeddings and optimizer after 5000 passes through the data
if self.total_iterations > 5000:
self.opt.zero_grad()
self.embedding_optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
self.embedding_optimizer.step()
else:
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# Updates embeddings and optimizer after 5000 passes through the data
if self.total_iterations > 5000:
self.opt.zero_grad()
self.embedding_optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
self.embedding_optimizer.step()
else:
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
# save the embedding back into the list
self.embedding_list = store_embedding_back(self.model,
self.embedding_list,
which_schedule)
# add average accuracy across pairwise comparisons to array
self.total_loss_array.append(running_loss_predict_tasks /
num_iterations_predict_task)
num_iterations_predict_task = 0
running_loss_predict_tasks = 0
self.total_iterations += 1
if self.total_iterations > 25 and self.total_iterations % 50 == 1:
print('total iterations is', self.total_iterations)
print('total loss (average for each 40, averaged)',
np.mean(self.total_loss_array[-40:]))
if self.total_iterations > 0 and self.total_iterations % self.when_to_save == self.when_to_save - 1:
print(self.embedding_list)
self.save_trained_nets()
if self.total_iterations > 8000 and np.mean(
self.total_loss_array[-100:]) - np.mean(
self.total_loss_array[-500:]) < self.covergence_epsilon:
training_done = True
def evaluate(self, load_in_model=False):
"""
Evaluate performance of a trained network tuned upon the alpha divergence loss.
This is tested on 20% of the data and will be stored in a text file.
Note this function is called after training convergence
:return:
"""
# define new optimizer that only optimizes gradient
loss_func = AlphaLoss()
checkpoint = self.model.state_dict().copy()
embedding_list_copy = self.embedding_list.copy()
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
if load_in_model:
self.model.load_state_dict(
torch.load(
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_baydimtest_'
+ str(self.bayesian_embedding_dim) +
'.tar')['nn_state_dict'])
# step through the cv set
for j in range(int(self.num_schedules * .8), self.num_schedules):
optimizer_for_embedding = self.opt = torch.optim.SGD([{
'params':
self.model.bayesian_embedding,
'lr':
.9
}])
load_in_embedding(self.model, self.embedding_list, j)
schedule_bounds = self.schedule_array[j]
step = schedule_bounds[
0] # starting index of schedule within the data
# until you complete schedule 1
while step < schedule_bounds[1]:
probability_matrix = np.zeros((20, 20))
for m, counter in enumerate(range(step, step + 20)):
phi_i = self.X[counter]
phi_i_numpy = np.asarray(phi_i)
# for each set of twenty
for n, second_counter in enumerate(range(step, step + 20)):
# fill entire array with diagnols set to zero
if second_counter == counter: # same as m = n
continue
phi_j = self.X[second_counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
13)).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
# push through nets
preference_prob = self.model.forward(feature_input)
probability_matrix[m][n] = preference_prob[
0].data.detach()[0].item()
probability_matrix[n][m] = preference_prob[
0].data.detach()[1].item()
# Set of twenty is completed
column_vec = np.sum(probability_matrix, axis=1)
# top 1
choice = np.argmax(column_vec)
# top 3
_, top_three = torch.topk(torch.Tensor(column_vec), 3)
# Then do training update loop
truth = self.Y[step]
# index top 1
if choice == truth:
prediction_accuracy[0] += 1
# index top 3
if truth in top_three:
prediction_accuracy[1] += 1
# forward
phi_i_num = truth + step # old method: set_of_twenty[0] + truth
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
if choice == truth:
pass
else:
for counter in range(step, step + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(
1, 13)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# update till convergence, or under 50 iterations
if loss.item() > .005:
flag = False
tracker = 0
while not flag:
optimizer_for_embedding.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), 0.5)
optimizer_for_embedding.step()
output = self.model(feature_input)
loss = loss_func.forward(
P, output, self.alpha)
tracker += 1
if tracker > 50:
flag = True
if loss.item() < .005:
flag = True
else:
pass
for counter in range(step, step + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(
1, 13)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# update till convergence, or under 50 iterations
if loss.item() > .005:
flag = False
tracker = 0
while not flag:
optimizer_for_embedding.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), 0.5)
optimizer_for_embedding.step()
output = self.model(feature_input)
loss = loss_func.forward(
P, output, self.alpha)
tracker += 1
if tracker > 50:
flag = True
if loss.item() < .005:
flag = True
else:
pass
# add average loss to array
self.embedding_list = store_embedding_back(
self.model, self.embedding_list, j)
step += 20
# schedule finished
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', j)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(percentage_accuracy_top1,
percentage_accuracy_top3)
self.model.load_state_dict(checkpoint)
self.embedding_list = embedding_list_copy
def save_trained_nets(self):
"""
saves the model
:return:
"""
torch.save(
{
'nn_state_dict': self.model.state_dict(),
'parameters': self.arguments
},
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_baydimtest_'
+ str(self.bayesian_embedding_dim) + '.tar')
def save_performance_results(self, top1, top3):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3)),
'alpha': self.alpha
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/pairwise_saved_models/',
special_string=str(self.bayesian_embedding_dim) +
'baydimtest.pkl')
def find_optimal_embedding(self):
"""
Searches through all .pkl files and returns the name of the file with the highest top 1 accuracy
:return:
"""
performance_files = glob.glob(
self.home_dir + '/saved_models/pairwise_saved_models/*test.pkl')
print(performance_files)
performance_files = performance_files
for i, file in enumerate(performance_files):
data: dict = pickle.load(open(file, 'rb'))
print(file, ': ', data['top1_mean'])
class ProLoTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, num_schedules):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = num_schedules
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_inf_hetero_deadline_pairwise.pkl'
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_data(
self.num_schedules, self.data)
self.start_of_each_set_twenty = create_sets_of_20_from_x_for_pairwise_comparisions(
self.X)
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=16,
output_dim=2,
bayesian_embedding_dim=8,
alpha=1.5,
use_gpu=True,
vectorized=True,
is_value=False)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
del params[0]
self.opt = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model.bayesian_embedding,
'lr': .001
}])
# TODO: make optimizers seperate
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
self.max_depth = 10
self.embedding_list = [
torch.ones(8) * 1 / 3 for _ in range(self.num_schedules)
]
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, produces training data using x_i - x_j
and trains upon that.
:return:
"""
threshold = .1
training_done = False
loss_func = AlphaLoss()
# deepening data
deepen_data = {'samples': [], 'labels': [], 'embedding_indices': []}
# variables to keep track of loss and number of tasks trained over
running_loss_predict_tasks = 0
num_iterations_predict_task = 0
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(
len(self.start_of_each_set_twenty))
set_of_twenty = self.start_of_each_set_twenty[
rand_timestep_within_sched]
truth = self.Y[set_of_twenty]
which_schedule = find_which_schedule_this_belongs_to(
self.schedule_array, set_of_twenty)
load_in_embedding(self.model, self.embedding_list, which_schedule)
# find feature vector of true action taken
phi_i_num = truth + set_of_twenty
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
deepen_data['samples'].append(np.array(feature_input))
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# NAN check (fix is in the bnn file)
if torch.isnan(loss):
print(self.alpha, ' :nan occurred at iteration ',
self.total_iterations)
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
if loss.item() < .001 or loss.item() > 50:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
deepen_data['labels'].extend([0])
deepen_data['embedding_indices'].extend([which_schedule])
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
deepen_data['samples'].append(np.array(feature_input))
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# if num_iterations_predict_task % 5 == 0:
# print('loss is :', loss.item())
# clip any very high gradients
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
if loss.item() < .001 or loss.item() > 50:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
deepen_data['labels'].extend([1])
deepen_data['embedding_indices'].extend([which_schedule])
# add average loss to array
# print(list(self.model.parameters()))
self.embedding_list = store_embedding_back(self.model,
self.embedding_list,
which_schedule)
self.total_loss_array.append(running_loss_predict_tasks /
num_iterations_predict_task)
num_iterations_predict_task = 0
running_loss_predict_tasks = 0
self.total_iterations += 1
if self.total_iterations > 25 and self.total_iterations % 50 == 1:
print('total iterations is', self.total_iterations)
print('total loss (average for each 40, averaged)',
np.mean(self.total_loss_array[-40:]))
if self.total_iterations > 0 and self.total_iterations % self.when_to_save == self.when_to_save - 1:
self.save_trained_nets('BDDT' + str(self.num_schedules))
threshold -= .025
# if self.total_iterations % 500 == 499:
# self.model = deepen_with_embeddings(self.model, deepen_data, self.embedding_list, max_depth=self.max_depth, threshold=threshold)
# params = list(self.model.parameters())
# del params[0]
# self.opt = torch.optim.RMSprop([{'params': params}, {'params': self.model.bayesian_embedding, 'lr': .001}])
# deepen_data = {
# 'samples': [],
# 'labels': [],
# 'embedding_indices': []
# }
if self.total_iterations > 5000 and np.mean(
self.total_loss_array[-100:]) - np.mean(
self.total_loss_array[-500:]) < self.covergence_epsilon:
training_done = True
def evaluate_on_test_data(self, load_in_model=False):
"""
Evaluate performance of a trained network tuned upon the alpha divergence loss.
Note this function is called after training convergence
:return:
"""
# define new optimizer that only optimizes gradient
num_schedules = 75
loss_func = AlphaLoss()
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/test/' + str(
num_schedules) + '_inf_hetero_deadline_pairwise.pkl'
data = pickle.load(open(load_directory, "rb"))
X, Y, schedule_array = create_new_data(num_schedules, data)
start_of_each_set_twenty = create_sets_of_20_from_x_for_pairwise_comparisions(
X)
embedding_optimizer = torch.optim.RMSprop([{
'params': self.model.bayesian_embedding,
'lr': .001
}])
embedding_list = [torch.ones(8) * 1 / 3 for _ in range(num_schedules)]
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
if load_in_model:
self.model.load_state_dict(
torch.load(
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_homog.tar'
)['nn_state_dict'])
for j in range(0, num_schedules):
schedule_bounds = schedule_array[j]
step = schedule_bounds[0]
load_in_embedding(self.model, embedding_list, j)
while step < schedule_bounds[1]:
probability_matrix = np.zeros((20, 20))
for m, counter in enumerate(range(step, step + 20)):
phi_i = X[counter]
phi_i_numpy = np.asarray(phi_i)
# for each set of twenty
for n, second_counter in enumerate(range(step, step + 20)):
# fill entire array with diagnols set to zero
if second_counter == counter: # same as m = n
continue
phi_j = X[second_counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
13)).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
# push through nets
preference_prob = self.model.forward(feature_input)
probability_matrix[m][n] = preference_prob[
0].data.detach()[0].item()
# probability_matrix[n][m] = preference_prob[0].data.detach()[1].item()
# Set of twenty is completed
column_vec = np.sum(probability_matrix, axis=1)
# top 1
choice = np.argmax(column_vec)
# top 3
_, top_three = torch.topk(torch.Tensor(column_vec), 3)
# Then do training update loop
truth = Y[step]
# index top 1
if choice == truth:
prediction_accuracy[0] += 1
# index top 3
if truth in top_three:
prediction_accuracy[1] += 1
# forward
phi_i_num = truth + step # old method: set_of_twenty[0] + truth
phi_i = X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(step, step + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
13)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# prepare optimizer, compute gradient, update params
if loss.item() < .001 or loss.item() > 50:
pass
else:
embedding_optimizer.zero_grad()
if loss.item() < .001 or loss.item() > 50:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), 0.5)
embedding_optimizer.step()
for counter in range(step, step + 20):
if counter == phi_i_num:
continue
else:
phi_j = X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
13)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# print('loss is :', loss.item())
# clip any very high gradients
# prepare optimizer, compute gradient, update params
if loss.item() < .001 or loss.item() > 50:
pass
else:
embedding_optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(
self.model.parameters(), 0.5)
embedding_optimizer.step()
# add average loss to array
embedding_list = store_embedding_back(self.model,
embedding_list, j)
step += 20
# schedule finished
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', j)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(percentage_accuracy_top1,
percentage_accuracy_top3,
'inf_BDT' + str(self.num_schedules))
def save_trained_nets(self, name):
"""
saves the model
:return:
"""
torch.save(
{
'nn_state_dict': self.model.state_dict(),
'parameters': self.arguments
},
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/BNN_'
+ name + '.tar')
def save_performance_results(self, top1, top3, special_string):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3))
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/pairwise_saved_models/',
special_string=special_string)
class BDTTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, bayesian_dim):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = 150
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_hetero_deadline_naive.pkl'
self.bayesian_embedding_dim = int(bayesian_dim)
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_dataset(
self.data, num_schedules=self.num_schedules)
for i, each_element in enumerate(self.X):
self.X[i] = each_element + list(range(20))
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
use_gpu = True
self.model = ProLoNet(
input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=4,
output_dim=20,
bayesian_embedding_dim=self.bayesian_embedding_dim,
alpha=1.5,
use_gpu=use_gpu,
vectorized=False,
is_value=False)
self.model_NLL = ProLoNet(
input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=4,
output_dim=20,
bayesian_embedding_dim=self.bayesian_embedding_dim,
alpha=1.5,
use_gpu=use_gpu,
vectorized=False,
is_value=False)
if use_gpu:
self.model = self.model.cuda()
self.model_NLL = self.model_NLL.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
del params[0]
self.opt = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model.bayesian_embedding,
'lr': .001
}])
params = list(self.model_NLL.parameters())
del params[0]
self.opt2 = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model_NLL.bayesian_embedding,
'lr': .001
}])
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
self.embedding_list = [
torch.ones(self.bayesian_embedding_dim) * 1 / 3
for _ in range(self.num_schedules)
]
self.embedding_list_NLL = [
torch.ones(self.bayesian_embedding_dim) * 1 / 3
for _ in range(self.num_schedules)
]
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled
:return:
"""
criterion = torch.nn.CrossEntropyLoss()
loss_func = AlphaLoss()
training_done = False
cv_cutoff = .8 * len(self.X)
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(cv_cutoff)
input_nn = self.X[rand_timestep_within_sched]
truth_nn = self.Y[rand_timestep_within_sched]
which_schedule = self.find_which_schedule_this_belongs_to(
rand_timestep_within_sched)
load_in_embedding(self.model, self.embedding_list, which_schedule)
load_in_embedding(self.model_NLL, self.embedding_list_NLL,
which_schedule)
# iterate over pairwise comparisons
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(
1, 242)).cuda()) # change to 5 to increase batch size
P = Variable(torch.Tensor(np.ones((1, 20)))).cuda()
P *= self.distribution_epsilon
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
P = Variable(
torch.Tensor(np.ones((1, 20) * self.distribution_epsilon)))
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)).long())
self.opt.zero_grad()
output = self.model.forward(input_nn)
loss = loss_func.forward(P, output, self.alpha)
loss.backward()
self.opt.step()
self.opt2.zero_grad()
output_nn = self.model_NLL.forward(input_nn)
loss_nn = criterion(output_nn, truth)
loss_nn.backward()
self.opt2.step()
self.total_loss_array.append(loss.item())
store_embedding_back(self.model, self.embedding_list,
which_schedule)
store_embedding_back(self.model_NLL, self.embedding_list_NLL,
which_schedule)
total_iterations = len(self.total_loss_array)
if total_iterations % 50 == 49:
print('loss at', total_iterations, 'is', loss.item())
print('loss_NN at', total_iterations, 'is', loss_nn.item())
if total_iterations > 100000:
training_done = True
def evaluate_alpha(self):
"""
Evaluate performance of a trained network.
This is tested on 20% of the data and will be stored in a text file.
:return:
"""
opt = torch.optim.RMSprop([{
'params': self.model.bayesian_embedding,
'lr': .001
}])
loss_func = AlphaLoss()
percentage_accuracy_top1 = []
for i, schedule in enumerate(self.schedule_array):
if i < .8 * len(self.schedule_array):
continue
load_in_embedding(self.model, self.embedding_list, i)
prediction_accuracy = 0
for count in range(schedule[0], schedule[1] + 1):
input_nn = self.X[count]
truth_nn = self.Y[count]
# if torch.cuda.is_available():
# input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242)).cuda())
# truth = Variable(torch.Tensor(np.asarray(truth).reshape(1)).cuda().long())
# else:
# input_nn = Variable(torch.Tensor(np.asarray(net_input).reshape(1, 242)))
# truth = Variable(torch.Tensor(np.asarray(truth).reshape(1)))
# iterate over pairwise comparisons
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(
1,
242)).cuda()) # change to 5 to increase batch size
P = Variable(torch.Tensor(np.ones((1, 20)))).cuda()
P *= self.distribution_epsilon
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
P = Variable(
torch.Tensor(
np.ones((1, 20) * self.distribution_epsilon)))
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)).long())
opt.zero_grad()
output = self.model.forward(input_nn)
loss = loss_func.forward(P, output, self.alpha)
loss.backward()
opt.step()
index = torch.argmax(output).item()
if index == truth.item():
prediction_accuracy += 1
print('Prediction Accuracy: top1: ', prediction_accuracy / 20)
store_embedding_back(self.model, self.embedding_list, i)
print('schedule num:', i)
percentage_accuracy_top1.append(prediction_accuracy / 20)
self.save_performance_results(percentage_accuracy_top1)
print(np.mean(percentage_accuracy_top1))
def evaluate_other(self):
"""
Evaluate performance of a trained network.
This is tested on 20% of the data and will be stored in a text file.
:return:
"""
opt = torch.optim.RMSprop([{
'params': self.model_NLL.bayesian_embedding,
'lr': .001
}])
criterion = torch.nn.CrossEntropyLoss()
percentage_accuracy_top1 = []
for i, schedule in enumerate(self.schedule_array):
if i < .8 * len(self.schedule_array):
continue
load_in_embedding(self.model, self.embedding_list, i)
prediction_accuracy = 0
for count in range(schedule[0], schedule[1] + 1):
input_nn = self.X[count]
truth_nn = self.Y[count]
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1,
242)).cuda())
truth = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
truth = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)))
opt.zero_grad()
output_nn = self.model_NLL.forward(input_nn)
loss_nn = criterion(output_nn, truth)
loss_nn.backward()
opt.step()
index = torch.argmax(output_nn).item()
if index == truth.item():
prediction_accuracy += 1
print('Prediction Accuracy: top1: ', prediction_accuracy / 20)
store_embedding_back(self.model_NLL, self.embedding_list, i)
print('schedule num:', i)
percentage_accuracy_top1.append(prediction_accuracy / 20)
self.save_performance_results(percentage_accuracy_top1)
print(np.mean(percentage_accuracy_top1))
def save_performance_results(self, top1):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'embedding': self.bayesian_embedding_dim
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/naive_saved_models/',
special_string=str(self.bayesian_embedding_dim) +
'baydim_naivetest.pkl')
def find_which_schedule_this_belongs_to(self, sample_val):
"""
Takes a sample and determines with schedule this belongs to.
Note: A schedule is task * task sized
:param sample_val: an int
:return: schedule num
"""
for i, each_array in enumerate(self.schedule_array):
if each_array[0] <= sample_val <= each_array[1]:
return i
else:
continue
class BDTTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = 150
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_inf_hetero_deadline_naive.pkl'
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_dataset(
self.data, num_schedules=self.num_schedules)
for i, each_element in enumerate(self.X):
self.X[i] = each_element + list(range(20))
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=256,
output_dim=20,
bayesian_embedding_dim=None,
alpha=1.5,
use_gpu=True,
vectorized=False,
is_value=False)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
self.opt = torch.optim.RMSprop([{'params': params}])
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled
:return:
"""
criterion = torch.nn.NLLLoss()
training_done = False
cv_cutoff = .8 * len(self.X)
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(cv_cutoff)
input_nn = self.X[rand_timestep_within_sched]
truth_nn = self.Y[rand_timestep_within_sched]
# iterate over pairwise comparisons
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(
1, 242)).cuda()) # change to 5 to increase batch size
truth_nn = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
truth_nn = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)))
self.opt.zero_grad()
output_nn = self.model.forward(input_nn)
loss_nn = criterion(output_nn, truth_nn)
loss_nn.backward()
self.opt.step()
self.total_loss_array.append(loss_nn.item())
total_iterations = len(self.total_loss_array)
if total_iterations % 50 == 49:
print('loss at', total_iterations, 'is', loss_nn.item())
if total_iterations > 15000:
training_done = True
def evaluate(self, load_in_model=False):
"""
Evaluate performance of a trained network.
This is tested on 20% of the data and will be stored in a text file.
:return:
"""
percentage_accuracy_top1 = []
for i, schedule in enumerate(self.schedule_array):
if i < .8 * len(self.schedule_array):
continue
prediction_accuracy = 0
for count in range(schedule[0], schedule[1] + 1):
net_input = self.X[count]
truth = self.Y[count]
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(
1, 242)).cuda())
truth = Variable(
torch.Tensor(
np.asarray(truth).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(1, 242)))
truth = Variable(torch.Tensor(
np.asarray(truth).reshape(1)))
#####forward#####
output = self.model.forward(input_nn)
index = torch.argmax(output).item()
if index == truth.item():
prediction_accuracy += 1
print('Prediction Accuracy: top1: ', prediction_accuracy / 20)
print('schedule num:', i)
percentage_accuracy_top1.append(prediction_accuracy / 20)
print(np.mean(percentage_accuracy_top1))
class ProLoTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = 150
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_homog_deadline_pairwise.pkl'
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_data(
self.num_schedules, self.data)
self.start_of_each_set_twenty = self.create_sets_of_20_from_x_for_pairwise_comparisions(
)
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=64,
output_dim=2,
bayesian_embedding_dim=None,
alpha=1.5,
use_gpu=True,
vectorized=True,
is_value=False)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
self.opt = torch.optim.RMSprop(params)
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
def create_sets_of_20_from_x_for_pairwise_comparisions(self):
"""
Create sets of 20 to denote each timestep for all schedules
:return: range(0, length_of_X, 20)
"""
length_of_X = len(self.X)
return list(range(0, length_of_X, 20))
def find_which_schedule_this_belongs_to(self, sample_val):
"""
Takes a sample and determines with schedule this belongs to.
Note: A schedule is task * task sized
:param sample_val: an int
:return: schedule num
"""
for i, each_array in enumerate(self.schedule_array):
if each_array[0] <= sample_val <= each_array[1]:
return i
else:
continue
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, produces training data using x_i - x_j
and trains upon that.
:return:
"""
# loss = nn.CrossEntropyLoss()
training_done = False
cv_cutoff = int(.8 * len(self.start_of_each_set_twenty))
loss_func = AlphaLoss()
# variables to keep track of loss and number of tasks trained over
running_loss_predict_tasks = 0
num_iterations_predict_task = 0
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(cv_cutoff)
set_of_twenty = self.start_of_each_set_twenty[
rand_timestep_within_sched]
truth = self.Y[set_of_twenty]
# find feature vector of true action taken
phi_i_num = truth + set_of_twenty
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
if torch.isnan(loss):
print(self.alpha, ' :nan occurred at iteration ',
self.total_iterations)
return
# TODO: can prob just set training to true here if network still outputs proper stuff
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# if num_iterations_predict_task % 5 == 0:
# print('loss is :', loss.item())
# clip any very high gradients
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
# add average loss to array
# print(list(self.model.parameters()))
self.total_loss_array.append(running_loss_predict_tasks /
num_iterations_predict_task)
num_iterations_predict_task = 0
running_loss_predict_tasks = 0
self.total_iterations += 1
if self.total_iterations > 25 and self.total_iterations % 50 == 1:
print('total iterations is', self.total_iterations)
print('total loss (average for each 40, averaged)',
np.mean(self.total_loss_array[-40:]))
# TODO: change running loss to actual loss
if self.total_iterations > 0 and self.total_iterations % self.when_to_save == self.when_to_save - 1:
# self.plot_nn()
self.save_trained_nets()
# self.evaluate()
if self.total_iterations > 5000 and np.mean(
self.total_loss_array[-100:]) - np.mean(
self.total_loss_array[-500:]) < self.covergence_epsilon:
training_done = True
def evaluate(self, load_in_model=False):
"""
Evaluate performance of a trained network tuned upon the alpha divergence loss.
This is tested on 20% of the data and will be stored in a text file.
Note this function is called after training convergence
:return:
"""
# define new optimizer that only optimizes gradient
loss_func = AlphaLoss()
checkpoint = self.model.state_dict().copy()
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
if load_in_model:
self.model.load_state_dict(
torch.load(
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_homog.tar'
)['nn_state_dict'])
# for rest of schedule
# i = .8 * len(self.start_of_each_set_twenty)
# num_test_schedules = 150 * .2
for j in range(int(self.num_schedules * .8), self.num_schedules):
schedule_bounds = self.schedule_array[j]
step = schedule_bounds[0]
while step < schedule_bounds[1]:
probability_matrix = np.zeros((20, 20))
for m, counter in enumerate(range(step, step + 20)):
phi_i = self.X[counter]
phi_i_numpy = np.asarray(phi_i)
# for each set of twenty
for n, second_counter in enumerate(range(step, step + 20)):
# fill entire array with diagnols set to zero
if second_counter == counter: # same as m = n
continue
phi_j = self.X[second_counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
13)).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 13)))
# push through nets
preference_prob = self.model.forward(feature_input)
probability_matrix[m][n] = preference_prob[
0].data.detach()[0].item()
probability_matrix[n][m] = preference_prob[
0].data.detach()[1].item()
# Set of twenty is completed
column_vec = np.sum(probability_matrix, axis=1)
# top 1
choice = np.argmax(column_vec)
# top 3
_, top_three = torch.topk(torch.Tensor(column_vec), 3)
# Then do training update loop
truth = self.Y[step]
# index top 1
if choice == truth:
prediction_accuracy[0] += 1
# index top 3
if truth in top_three:
prediction_accuracy[1] += 1
# add average loss to array
step += 20
# schedule finished
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', j)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(percentage_accuracy_top1,
percentage_accuracy_top3)
self.model.load_state_dict(checkpoint)
def save_trained_nets(self):
"""
saves the model
:return:
"""
torch.save(
{
'nn_state_dict': self.model.state_dict(),
'parameters': self.arguments
},
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_homog.tar'
)
def save_performance_results(self, top1, top3):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3)),
'alpha': self.alpha
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/pairwise_saved_models/',
special_string='homog.pkl')
if np.mean(top1) > .6:
exit()
class BDTTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, num_schedules):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = num_schedules
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_inf_hetero_deadline_naive.pkl'
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_dataset(
self.data, num_schedules=self.num_schedules)
for i, each_element in enumerate(self.X):
self.X[i] = each_element + list(range(20))
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=256,
output_dim=20,
bayesian_embedding_dim=None,
alpha=1.5,
use_gpu=True,
vectorized=False,
is_value=False)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
self.opt = torch.optim.RMSprop([{'params': params}])
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled
:return:
"""
loss_func = AlphaLoss()
training_done = False
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(len(self.X))
input_nn = self.X[rand_timestep_within_sched]
truth_nn = self.Y[rand_timestep_within_sched]
# iterate over pairwise comparisons
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(
1, 242)).cuda()) # change to 5 to increase batch size
P = Variable(torch.Tensor(np.ones((1, 20)))).cuda()
P *= self.distribution_epsilon
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
P = Variable(
torch.Tensor(np.ones((1, 20) * self.distribution_epsilon)))
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)).long())
self.opt.zero_grad()
output = self.model.forward(input_nn)
loss = loss_func.forward(P, output, self.alpha)
if loss.item() < .05 or loss.item() > 5:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 0.5)
self.opt.step()
self.total_loss_array.append(loss.item())
total_iterations = len(self.total_loss_array)
if total_iterations % 50 == 49:
print('loss at', total_iterations, 'is', loss.item())
if total_iterations > 15000:
training_done = True
def evaluate_on_test_set(self, load_in_model=False):
"""
Evaluate performance of a trained network.
This is tested on 20% of the data and will be stored in a text file.
:return:
"""
num_schedules = 75
# load in new data
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/test/' + str(
num_schedules) + '_inf_hetero_deadline_naive.pkl'
data = pickle.load(open(load_directory, "rb"))
X, Y, schedule_array = create_new_dataset(data, num_schedules)
for i, each_element in enumerate(X):
X[i] = each_element + list(range(20))
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
for i, schedule in enumerate(schedule_array):
for count in range(schedule[0], schedule[1] + 1):
net_input = X[count]
truth = Y[count]
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(
1, 242)).cuda())
truth = Variable(
torch.Tensor(
np.asarray(truth).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(1, 242)))
truth = Variable(torch.Tensor(
np.asarray(truth).reshape(1)))
#####forward#####
output = self.model.forward(input_nn)
index = torch.argmax(output).item()
# top 3
_, top_three = torch.topk(output, 3)
if index == truth.item():
prediction_accuracy[0] += 1
if truth.item() in top_three.detach().cpu().tolist()[0]:
prediction_accuracy[1] += 1
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', i)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(
percentage_accuracy_top1, percentage_accuracy_top3,
'inf_DDT_small_' + str(self.num_schedules))
def save_performance_results(self, top1, top3, special_string):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3))
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/naive_saved_models/',
special_string=special_string)
class BDTTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, alpha):
self.arguments = Logger()
self.alpha = alpha
self.num_schedules = 150
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/scheduling_environment/new_data_pickle/' + str(
self.num_schedules) + 'pairwise.pkl'
bayesian_embedding_dim = 4
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_dataset(
self.num_schedules)
self.embedding_list = [
torch.ones(bayesian_embedding_dim) * 1 / 3
for _ in range(self.num_schedules)
]
# device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=64,
output_dim=2,
bayesian_embedding_dim=bayesian_embedding_dim,
alpha=1.5,
use_gpu=True,
vectorized=False,
is_value=False).cuda()
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
del params[0]
self.opt = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model.bayesian_embedding,
'lr': .001
}])
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
def train(self):
"""
Trains BDT.
Randomly samples a schedule and timestep within that schedule, and passes in the corresponding data in an attempt to classify which task was scheduled
:return:
"""
# loss = nn.CrossEntropyLoss()
training_done = False
cv_cutoff = .8 * len(self.X)
loss_func = AlphaLoss()
# variables to keep track of loss and number of tasks trained over
running_loss_predict_tasks = 0
num_iterations_predict_task = 0
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(cv_cutoff)
which_schedule = self.find_which_schedule_this_belongs_to(
set_of_twenty)
load_in_embedding(self.model, self.embedding_list, which_schedule)
# find feature vector of true action taken
phi_i_num = truth + set_of_twenty
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
for counter in range(set_of_twenty, set_of_twenty + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# if num_iterations_predict_task % 5 == 0:
# print('loss is :', loss.item())
# clip any very high gradients
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
running_loss_predict_tasks += loss.item()
num_iterations_predict_task += 1
# add average loss to array
# print(list(self.model.parameters()))
store_embedding_back(self.model, self.embedding_list,
which_schedule)
self.total_loss_array.append(running_loss_predict_tasks /
num_iterations_predict_task)
num_iterations_predict_task = 0
running_loss_predict_tasks = 0
self.total_iterations += 1
if self.total_iterations > 25 and self.total_iterations % 50 == 1:
print('total iterations is', self.total_iterations)
print('total loss (average for each 40, averaged)',
np.mean(self.total_loss_array[-40:]))
# TODO: change running loss to actual loss
if self.total_iterations > 0 and self.total_iterations % self.when_to_save == self.when_to_save - 1:
# self.plot_nn()
print(self.embedding_list)
self.save_trained_nets()
# self.evaluate()
if self.total_iterations > 10000 and np.mean(
self.total_loss_array[-100:]) - np.mean(
self.total_loss_array[-500:]) < self.covergence_epsilon:
training_done = True
def evaluate(self, load_in_model=False):
# TODO: can be changed to one batched forward pass
"""
Evaluate performance of a trained network tuned upon the alpha divergence loss.
This is tested on 20% of the data and will be stored in a text file.
Note this function is called after training convergence
:return:
"""
# define new optimizer that only optimizes gradient
loss_func = AlphaLoss()
checkpoint = self.model.state_dict().copy()
optimizer_for_embedding = self.opt = torch.optim.RMSprop([{
'params':
self.model.bayesian_embedding,
'lr':
.0001
}])
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
if load_in_model:
self.model.load_state_dict(
torch.load(
'/home/ghost/PycharmProjects/bayesian_prolo/model.tar')
['nn_state_dict'])
# for rest of schedule
# i = .8 * len(self.start_of_each_set_twenty)
# num_test_schedules = 150 * .2
for j in range(int(self.num_schedules * .8), self.num_schedules):
load_in_embedding(self.model, self.embedding_list, j)
schedule_bounds = self.schedule_array[j]
step = schedule_bounds[0]
while step < schedule_bounds[1]:
probability_matrix = np.zeros((20, 20))
for m, counter in enumerate(range(step, step + 20)):
phi_i = self.X[counter]
phi_i_numpy = np.asarray(phi_i)
# for each set of twenty
for n, second_counter in enumerate(range(step, step + 20)):
# fill entire array with diagnols set to zero
if second_counter == counter: # same as m = n
continue
phi_j = self.X[second_counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
12)).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)))
# push through nets
preference_prob = self.model.forward(feature_input)
probability_matrix[m][n] = preference_prob[
0].data.detach()[0].item()
probability_matrix[n][m] = preference_prob[
0].data.detach()[1].item()
# Set of twenty is completed
column_vec = np.sum(probability_matrix, axis=1)
# top 1
choice = np.argmax(column_vec)
# top 3
_, top_three = torch.topk(torch.Tensor(column_vec), 3)
# Then do training update loop
truth = self.Y[step]
# index top 1
if choice == truth:
prediction_accuracy[0] += 1
# index top 3
if truth in top_three:
prediction_accuracy[1] += 1
# forward
phi_i_num = truth + step # old method: set_of_twenty[0] + truth
phi_i = self.X[phi_i_num]
phi_i_numpy = np.asarray(phi_i)
# iterate over pairwise comparisons
for counter in range(step, step + 20):
if counter == phi_i_num: # if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_i_numpy - phi_j_numpy
# label = add_noise_pairwise(label, self.noise_percentage)
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
12)).cuda())
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)))
P = Variable(
torch.Tensor([
1 - self.distribution_epsilon,
self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# prepare optimizer, compute gradient, update params
optimizer_for_embedding.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
optimizer_for_embedding.step()
for counter in range(step, step + 20):
if counter == phi_i_num:
continue
else:
phi_j = self.X[counter]
phi_j_numpy = np.asarray(phi_j)
feature_input = phi_j_numpy - phi_i_numpy
if torch.cuda.is_available():
feature_input = Variable(
torch.Tensor(feature_input.reshape(1,
12)).cuda())
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]).cuda())
else:
feature_input = Variable(
torch.Tensor(feature_input.reshape(1, 12)))
P = Variable(
torch.Tensor([
self.distribution_epsilon,
1 - self.distribution_epsilon
]))
output = self.model(feature_input)
loss = loss_func.forward(P, output, self.alpha)
# print('loss is :', loss.item())
# clip any very high gradients
# prepare optimizer, compute gradient, update params
self.opt.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
self.opt.step()
# add average loss to array
store_embedding_back(self.model, self.embedding_list, j)
step += 20
# schedule finished
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', j)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(percentage_accuracy_top1,
percentage_accuracy_top3)
self.model.load_state_dict(checkpoint)
def save_trained_nets(self):
"""
saves the model
:return:
"""
torch.save(
{
'nn_state_dict': self.model.state_dict(),
'parameters': self.arguments
},
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/uniform_model'
+ str(self.alpha) + '.tar')
def save_performance_results(self, top1, top3):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3)),
'alpha': self.alpha
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/pairwise_saved_models/',
special_string=str(self.alpha) + 'uniform_alpha.pkl')
if np.mean(top1) > .6:
exit()
# TODO: function that searches through all the saved means and stderr, plots, and finds the highest
def find_optimal_alpha(self):
"""
Searches through all .pkl files and returns the name of the file with the highest top 1 accuracy
:return:
"""
performance_files = glob.glob(self.home_dir + '/*.pkl')
performance_files2 = glob.glob(
self.home_dir + '/saved_models/pairwise_saved_models/*.pkl')
print(performance_files2)
performance_files = performance_files + performance_files2
max_val = 0
max_filename = None
for i, file in enumerate(performance_files):
data = pickle.load(open(file, 'rb'))
print(data['top1_mean'])
if data['top1_mean'] > max_val:
max_val = data['top1_mean']
max_filename = file
print('The optimal alpha is: ', max_filename, 'with an accuracy of: ',
max_val)
print(
'The exact value of alpha can be found by dividing the digits before the .tar by 10'
)
class ProLoTrain:
"""
class structure to train the BDT with a certain alpha.
This class handles training the BDT, evaluating the BDT, and saving
"""
def __init__(self, num_schedules):
self.arguments = Logger()
self.alpha = .9
self.num_schedules = num_schedules
self.home_dir = self.arguments.home_dir
self.total_loss_array = []
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/' + str(
self.num_schedules) + '_inf_hetero_deadline_naive.pkl'
self.data = pickle.load(open(load_directory, "rb"))
self.X, self.Y, self.schedule_array = create_new_dataset(
num_schedules=self.num_schedules, data=self.data)
for i, each_element in enumerate(self.X):
self.X[i] = each_element + list(range(20))
self.model = ProLoNet(input_dim=len(self.X[0]),
weights=None,
comparators=None,
leaves=16,
output_dim=20,
bayesian_embedding_dim=8,
alpha=1.5,
use_gpu=True,
vectorized=True,
is_value=False)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
params = list(self.model.parameters())
del params[0]
self.opt = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model.bayesian_embedding,
'lr': .001
}])
self.num_iterations_predict_task = 0
self.total_iterations = 0
self.covergence_epsilon = .01
self.when_to_save = 1000
self.distribution_epsilon = .0001
self.max_depth = 10 # TODO: add back in deepening
self.embedding_list = [
torch.ones(8) * 1 / 3 for _ in range(self.num_schedules)
]
def train(self):
"""
Trains PDDT.
:return:
"""
threshold = .05
training_done = False
loss_func = AlphaLoss()
# deepening data
deepen_data = {'samples': [], 'labels': [], 'embedding_indices': []}
while not training_done:
# sample a timestep before the cutoff for cross_validation
rand_timestep_within_sched = np.random.randint(len(self.X))
input_nn = self.X[rand_timestep_within_sched]
truth_nn = self.Y[rand_timestep_within_sched]
which_schedule = find_which_schedule_this_belongs_to(
self.schedule_array, rand_timestep_within_sched)
load_in_embedding(self.model, self.embedding_list, which_schedule)
deepen_data['samples'].append(np.array(input_nn))
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(
1, 242)).cuda()) # change to 5 to increase batch size
P = Variable(torch.Tensor(np.ones((1, 20)))).cuda()
P *= self.distribution_epsilon
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(
np.asarray(truth_nn).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(input_nn).reshape(1, 242)))
P = Variable(
torch.Tensor(np.ones((1, 20) * self.distribution_epsilon)))
P[0][truth_nn] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(np.asarray(truth_nn).reshape(1)).long())
self.opt.zero_grad()
output = self.model.forward(input_nn)
loss = loss_func.forward(P, output, self.alpha)
if loss.item() < .001 or loss.item() > 30:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 0.5)
self.opt.step()
deepen_data['labels'].extend([truth.item()])
deepen_data['embedding_indices'].extend([which_schedule])
# add average loss to array
# print(list(self.model.parameters()))
self.embedding_list = store_embedding_back(self.model,
self.embedding_list,
which_schedule)
self.total_loss_array.append(loss.item())
self.total_iterations += 1
if self.total_iterations > 25 and self.total_iterations % 50 == 1:
print('total iterations is', self.total_iterations)
print('total loss (average for each 40, averaged)',
np.mean(self.total_loss_array[-40:]))
if self.total_iterations > 0 and self.total_iterations % self.when_to_save == self.when_to_save - 1:
self.save_trained_nets('BDDT' + str(self.num_schedules))
threshold -= .1
if self.total_iterations % 500 == 499:
self.model = deepen_with_embeddings(
self.model,
deepen_data,
self.embedding_list,
max_depth=self.max_depth,
threshold=threshold /
len(self.model.leaf_init_information))
params = list(self.model.parameters())
del params[0]
self.opt = torch.optim.RMSprop([{
'params': params
}, {
'params': self.model.bayesian_embedding,
'lr': .001
}])
deepen_data = {
'samples': [],
'labels': [],
'embedding_indices': []
}
if self.total_iterations > 5000 and np.mean(
self.total_loss_array[-100:]) - np.mean(
self.total_loss_array[-500:]) < self.covergence_epsilon:
training_done = True
def evaluate_on_test_data(self, load_in_model=False):
"""
Evaluate performance of a trained network tuned upon the alpha divergence loss.
Note this function is called after training convergence
:return:
"""
# define new optimizer that only optimizes gradient
num_schedules = 75
loss_func = AlphaLoss()
load_directory = '/home/ghost/PycharmProjects/bayesian_prolo/scheduling_env/datasets/test/' + str(
num_schedules) + '_inf_hetero_deadline_naive.pkl'
data = pickle.load(open(load_directory, "rb"))
X, Y, schedule_array = create_new_dataset(num_schedules=num_schedules,
data=data)
for i, each_element in enumerate(X):
X[i] = each_element + list(range(20))
embedding_optimizer = torch.optim.RMSprop([{
'params': self.model.bayesian_embedding,
'lr': .001
}])
embedding_list = [torch.ones(8) * 1 / 3 for _ in range(num_schedules)]
prediction_accuracy = [0, 0]
percentage_accuracy_top1 = []
percentage_accuracy_top3 = []
if load_in_model:
self.model.load_state_dict(
torch.load(
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/pairwise_saved_models/model_homog.tar'
)['nn_state_dict'])
for i, schedule in enumerate(schedule_array):
load_in_embedding(self.model, embedding_list, i)
for count in range(schedule[0], schedule[1] + 1):
net_input = X[count]
truth = Y[count]
if torch.cuda.is_available():
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(
1,
242)).cuda()) # change to 5 to increase batch size
P = Variable(torch.Tensor(np.ones((1, 20)))).cuda()
P *= self.distribution_epsilon
P[0][truth] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(
np.asarray(truth).reshape(1)).cuda().long())
else:
input_nn = Variable(
torch.Tensor(np.asarray(net_input).reshape(1, 242)))
P = Variable(
torch.Tensor(
np.ones((1, 20) * self.distribution_epsilon)))
P[0][truth] = 1 - 19 * self.distribution_epsilon
truth = Variable(
torch.Tensor(np.asarray(truth).reshape(1)).long())
#####forward#####
output = self.model.forward(input_nn)
embedding_optimizer.zero_grad()
loss = loss_func.forward(P, output, self.alpha)
if loss.item() < .001 or loss.item() > 30:
pass
else:
loss.backward()
torch.nn.utils.clip_grad_norm_(self.model.parameters(),
0.5)
embedding_optimizer.step()
index = torch.argmax(output).item()
# top 3
_, top_three = torch.topk(output, 3)
if index == truth.item():
prediction_accuracy[0] += 1
if truth.item() in top_three.detach().cpu().tolist()[0]:
prediction_accuracy[1] += 1
# add average loss to array
embedding_list = store_embedding_back(self.model, embedding_list,
i)
# schedule finished
print('Prediction Accuracy: top1: ', prediction_accuracy[0] / 20,
' top3: ', prediction_accuracy[1] / 20)
print('schedule num:', i)
percentage_accuracy_top1.append(prediction_accuracy[0] / 20)
percentage_accuracy_top3.append(prediction_accuracy[1] / 20)
prediction_accuracy = [0, 0]
self.save_performance_results(percentage_accuracy_top1,
percentage_accuracy_top3,
'inf_BDT' + str(self.num_schedules))
def save_trained_nets(self, name):
"""
saves the model
:return:
"""
torch.save(
{
'nn_state_dict': self.model.state_dict(),
'parameters': self.arguments
},
'/home/ghost/PycharmProjects/bayesian_prolo/saved_models/naive_saved_models/BNN_'
+ name + '.tar')
def save_performance_results(self, top1, top3, special_string):
"""
saves performance of top1 and top3
:return:
"""
print('top1_mean for ', self.alpha, ' is : ', np.mean(top1))
data = {
'top1_mean': np.mean(top1),
'top3_mean': np.mean(top3),
'top1_stderr': np.std(top1) / np.sqrt(len(top1)),
'top3_stderr': np.std(top3) / np.sqrt(len(top3))
}
save_pickle(file=data,
file_location=self.home_dir +
'/saved_models/naive_saved_models/',
special_string=special_string)