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) + 'dist_early_hili_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=32,
output_dim=1,
bayesian_embedding_dim=8,
alpha=1.5,
use_gpu=True,
vectorized=True,
is_value=True)
use_gpu = True
if use_gpu:
self.model = self.model.cuda()
print(self.model.state_dict())
self.opt = torch.optim.RMSprop(
[{
'params': list(self.model.parameters())[:-1]
}, {
'params': self.model.bayesian_embedding.parameters(),
'lr': .01
}],
lr=.01)
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(8) * 1 / 3 for _ in range(self.num_schedules)
]
def __init__(self):
self.loss_array = []
checkpoint = torch.load(
'/home/ghost/PycharmProjects/scheduling_environment/learn_action_embeddings.pkl'
)
self.action_embedding_list = checkpoint['embedding_list']
self.all_data_train_dir = '/home/ghost/PycharmProjects/scheduling_environment' + '/training_encoding_states_starcraft'
self.mmr = '/home/ghost/PycharmProjects/scheduling_environment' + '/games_that_have_an_win_loss.pkl'
self.list_of_games_mmr_train = pickle.load(open(self.mmr, "rb"))
self.size_of_training_set = len(self.list_of_games_mmr_train)
self.all_data_test_dir = '/home/ghost/PycharmProjects/scheduling_environment/testing_encoding_states_starcraft'
self.gamma = .9
self.criterion = torch.nn.BCELoss()
self.not_converged = True
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
self.embedding_list_Bayesian_neur_net = [
torch.ones(12) * 1 / 2 for i in range(4000)
]
self.model = ProLoNet(input_dim=256 + 36,
weights=None,
comparators=None,
leaves=64,
output_dim=1,
bayesian_embedding_dim=12,
alpha=1.5,
use_gpu=True,
vectorized=True,
is_value=True)
self.optimizer_main_net = torch.optim.Adam(
[{
'params': list(self.model.parameters())[:-1]
}, {
'params': self.model.bayesian_embedding.parameters(),
'lr': .01
}],
lr=.001)
self.embedding_optimizer_bnn = torch.optim.SGD(
self.model.bayesian_embedding.parameters(), lr=.1)
x_test.append(each_ele[2:])
x_test = torch.Tensor(x_test).reshape(-1, 1, 2)
y_test = torch.Tensor(y_test).reshape((-1, 1))
print('test set generated')
input_size = 2 # Just the x dimension
hidden_size = 10 # The number of nodes at the hidden layer
num_classes = 2 # The number of output classes. In this case, from 0 to 1
learning_rate = 1e-3 # The speed of convergence
ddt = ProLoNet(input_dim=input_size,
output_dim=num_classes,
weights=None,
comparators=None,
leaves=4,
is_value=False,
vectorized=True,
selectors=None)
optimizer = torch.optim.Adam(ddt.parameters(), lr=learning_rate)
epochs = 10
schedule_starts = np.linspace(0, 20 * (num_schedules - 1), num=num_schedules)
for epoch in range(epochs): # loop over the dataset multiple times
# for batch, (x_train, y_train) in enumerate(train_loader):
for i in range(num_schedules):
chosen_schedule_start = int(np.random.choice(schedule_starts))
for each_t in range(chosen_schedule_start, chosen_schedule_start + 20):
optimizer.zero_grad()
pred = ddt(x[each_t])
loss = F.cross_entropy(pred.reshape(1, 2), y[each_t].long())
def train():
# Training set generation
num_schedules = 50
x_data, y = create_simple_classification_dataset(num_schedules, train=True)
x = []
for each_ele in x_data:
x.append(each_ele[2:])
x = torch.Tensor(x).reshape(-1, 1, 2)
y = torch.Tensor(y).reshape((-1, 1))
print('Toy problem generated, and data cleaned')
input_size = 2 # Just the x and z dimension
hidden_size = 10 # The number of nodes at the hidden layer
num_classes = 2 # The number of output classes. In this case, from 0 to 1
learning_rate = 1e-3 # The speed of convergence
ddt = ProLoNet(input_dim=input_size,
output_dim=num_classes,
weights=None,
comparators=None,
leaves=32,
is_value=False,
bayesian_embedding_dim=2,
vectorized=True,
selectors=None)
distributions = [np.ones(2) * 1 / 2 for _ in range(num_schedules)]
criterion = torch.nn.CrossEntropyLoss()
opt = torch.optim.SGD(ddt.parameters(), lr=.001)
schedule_starts = np.linspace(0,
int(num_schedules * 20 - 20),
num=num_schedules)
epochs = 150
for epoch in range(epochs): # loop over the dataset multiple times
for _ in range(num_schedules):
# choose a schedule
chosen_schedule_start = int(np.random.choice(schedule_starts))
schedule_num = int(chosen_schedule_start / 20)
# embedding_given_dis = get_embedding_given_dist(distributions[schedule_num])
prod = [0, 0]
# for each embedding
opt.zero_grad()
test_models = [0, 0]
losses = [0, 0]
for count, each_i in enumerate(
[torch.Tensor([1, 0]),
torch.Tensor([0, 1])]):
# model_copy = NeuronBNN()
# model_copy.load_state_dict(model.state_dict())
# test_models[count] = model_copy
ddt.set_bayesian_embedding(each_i)
tally = 1
avg_loss_over_schedule = 0
for each_t in range(chosen_schedule_start,
chosen_schedule_start + 20):
x_t = x[each_t]
output = ddt.forward(x_t).reshape(1, 2)
label = y[each_t]
label = torch.Tensor([label]).reshape(1)
label = label.long()
loss = criterion(output, label)
# loss.backward()
losses[count] += loss
avg_loss_over_schedule += loss.item()
# print('output is ', torch.argmax(output).item(), ' label is ', label.item())
tally *= output[0][int(label.item())].item()
prod[count] = tally * distributions[schedule_num][count]
if max(distributions[schedule_num]) == distributions[
schedule_num][count]: # if you choose correctly
print("avg loss over schedule is: ",
avg_loss_over_schedule / 20)
normalization_factor = sum(prod)
prod = [i / normalization_factor for i in prod]
# update each
distributions[schedule_num][0] = prod[0]
distributions[schedule_num][1] = prod[1]
normalization_factor_for_dist = sum(distributions[schedule_num])
distributions[
schedule_num] /= normalization_factor_for_dist # [i/normalization_factor_for_dist for i in distributions[schedule_num]]
coin_flip = np.random.choice([0, 1],
p=[
distributions[schedule_num][0],
distributions[schedule_num][1]
])
chosen_loss = losses[int(coin_flip)]
chosen_loss.backward()
# opt = torch.optim.SGD(test_models[coin_flip].parameters(), lr=.001)
opt.step()
# model.load_state_dict(test_models[coin_flip].state_dict())
print('Finished Training')
return ddt
doesn't do anything
:return:
"""
return
input_size = 2 # Just the x dimension
hidden_size = 10 # The number of nodes at the hidden layer
num_classes = 2 # The number of output classes. In this case, from 0 to 1
learning_rate = 1e-3 # The speed of convergence
ddt = ProLoNet(input_dim=input_size,
output_dim=num_classes,
weights=None,
comparators=None,
leaves=8,
is_value=False,
bayesian_embedding_dim=2,
vectorized=True,
selectors=None)
optimizer = torch.optim.SGD([{
'params': list(ddt.parameters())[:-1]
}, {
'params': ddt.bayesian_embedding.parameters(),
'lr': .01
}],
lr=learning_rate)
solo_embedding_optimizer = torch.optim.SGD(
[{
'params': ddt.bayesian_embedding.parameters()