def attachToNextLayer(self, layer: NeuralLayer):
self.next_layer = layer
layer.prev_layer = self
if type(self) is not InputLayer:
n_neurons_in_prev_layer = len(self.prev_layer.neurons)
else:
n_neurons_in_prev_layer = len(self.neurons)
for neuron in self.neurons:
neuron.weights = utils.generate_weights(n_neurons_in_prev_layer)
neuron.next_weights = utils.generate_zeros(n_neurons_in_prev_layer)
neuron.partial_error_derivatives = utils.generate_zeros(
n_neurons_in_prev_layer)
neuron.prev_weights = utils.generate_zeros(n_neurons_in_prev_layer)
bias = utils.generate_bias()
if type(layer) == OutputLayer:
output_layer = layer
n_neurons_in_prev_layer = len(output_layer.prev_layer.neurons)
for output_neuron in output_layer.neurons:
output_neuron.weights = utils.generate_weights(
n_neurons_in_prev_layer)
output_neuron.next_weights = utils.generate_zeros(
n_neurons_in_prev_layer)
output_neuron.partial_error_derivatives = utils.generate_zeros(
n_neurons_in_prev_layer)
output_neuron.prev_weights = utils.generate_zeros(
n_neurons_in_prev_layer)
output_layer.bias = utils.generate_bias()
return layer
def attachToNextLayer(self, layer: NeuralLayer):
self.next_layer = layer
layer.prev_layer = self
for neuron in self.neurons:
neuron.weights = utils.generate_weights(len(layer.neurons))
neuron.next_weights = utils.generate_zeros(len(layer.neurons))
neuron.partial_error_derivatives = utils.generate_zeros(
len(layer.neurons))
neuron.prev_weights = utils.generate_zeros(len(layer.neurons))
bias = utils.generate_bias()
return layer
learn_rate = optimizer.param_groups[0][
'lr'] # for when it may be modified during run
model.train()
pred = torch.Tensor()
tr_weights = torch.Tensor()
loss = []
cum_pred = torch.Tensor().to(device)
cum_labels = torch.Tensor().to(device)
for batch in tqdm(train_loader, desc='Training.'):
batch = batch.to(device)
optimizer.zero_grad()
out = model(batch)
labels = batch.y.to(device)
weights = generate_weights(labels).to(device)
tr_loss = F.binary_cross_entropy(out, target=labels, weight=weights)
loss.append(tr_loss.detach().item())
tr_loss.backward()
optimizer.step()
cum_labels = torch.cat((cum_labels, labels.clone().detach()), dim=0)
cum_pred = torch.cat((cum_pred, out.clone().detach()), dim=0)
train_precision = precision(cum_pred, cum_labels, 2)[1].item()
train_recall = recall(cum_pred, cum_labels, 2)[1].item()
train_f1 = f1_score(cum_pred, cum_labels, 2)[1].item()
roc_auc = roc_auc_score(cum_labels.cpu(), cum_pred.cpu())
loss = mean(loss)
# -------------- REPORTING ------------------------------------
batch_size=p.test_batch_size)
masked_loader = DataLoader(maskedset,
shuffle=False,
batch_size=p.test_batch_size)
model.train()
first_batch_labels = torch.Tensor()
pred = torch.Tensor()
loss = []
for batch_n, batch in enumerate(train_loader):
batch = batch.to(device)
optimizer.zero_grad()
out, _ = model(batch)
labels = batch.y.to(device)
weights = generate_weights(labels).to(device)
tr_loss = F.binary_cross_entropy(out,
target=labels,
weight=weights)
loss.append(tr_loss.detach().item())
tr_loss.backward()
optimizer.step()
if batch_n == 0:
first_batch_labels = labels.clone().detach().to(device)
pred = out.clone().detach().round().to(device)
loss = mean(loss)
# -------------- EVALUATION & REPORTING ------------------------------------
roc_auc = roc_auc_score(first_batch_labels.cpu(), pred.cpu())
with torch.no_grad():
def train(args):
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
dataset = pickle.load(
open("data/" + args.expert_file + "_" + str(args.num_sampled), "rb"))
dataset.min_reward = 0
dataset.max_reward = 1
action_getter = utils.ActionGetter(
atari.env.action_space.n,
replay_memory_start_size=REPLAY_MEMORY_START_SIZE,
max_frames=MAX_FRAMES,
eps_initial=args.initial_exploration)
utils.generate_weights(dataset)
saver = tf.train.Saver(max_to_keep=10)
sess = tf.Session(config=config)
sess.run(init)
fixed_state = np.expand_dims(atari.fixed_state(sess), axis=0)
if args.checkpoint_index >= 0:
saver.restore(
sess, args.checkpoint_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/" + "model--" + str(args.checkpoint_index))
print(
"Loaded Model ... ", args.checkpoint_dir + args.env_id + "seed_" +
str(args.seed) + "/" + "model--" + str(args.checkpoint_index))
logger.configure(args.log_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/")
if not os.path.exists(args.gif_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/"):
os.makedirs(args.gif_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/")
if not os.path.exists(args.checkpoint_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/"):
os.makedirs(args.checkpoint_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/")
frame_number = 0
loss_list = []
epoch = 0
while frame_number < MAX_FRAMES:
print("Training Model ...")
epoch_frame = 0
start_time = time.time()
for j in tqdm(range(EVAL_FREQUENCY // BS)):
loss = learn(sess,
dataset,
MAIN_DQN,
TARGET_DQN,
BS,
gamma=DISCOUNT_FACTOR) # (8★)
loss_list.append(loss)
# Output the progress:
# logger.log("Runing frame number {0}".format(frame_number))
logger.record_tabular("frame_number", frame_number)
logger.record_tabular("td loss", np.mean(loss_list[-100:]))
q_vals = sess.run(MAIN_DQN.action_prob,
feed_dict={MAIN_DQN.input: fixed_state})
for i in range(atari.env.action_space.n):
logger.record_tabular("q_val action {0}".format(i), q_vals[0, i])
utils.test_q_values(sess, dataset, atari, action_getter, MAIN_DQN,
MAIN_DQN.input, MAIN_DQN.action_prob_expert, BS)
print("Current Frame: ", frame_number)
print("TD Loss: ", np.mean(loss_list[-100:]))
# Evaluation ...
gif = True
frames_for_gif = []
eval_rewards = []
evaluate_frame_number = 0
print("Evaluating Model.... ")
while evaluate_frame_number < EVAL_STEPS:
terminal_life_lost = atari.reset(sess, evaluation=True)
episode_reward_sum = 0
for _ in range(MAX_EPISODE_LENGTH):
# Fire (action 1), when a life was lost or the game just started,
# so that the agent does not stand around doing nothing. When playing
# with other environments, you might want to change this...
action = 1 if terminal_life_lost and args.env_id == "BreakoutDeterministic-v4" else action_getter.get_action(
sess, frame_number, atari.state, MAIN_DQN, evaluation=True)
processed_new_frame, reward, terminal, terminal_life_lost, new_frame = atari.step(
sess, action)
evaluate_frame_number += 1
episode_reward_sum += reward
if gif:
frames_for_gif.append(new_frame)
if terminal:
eval_rewards.append(episode_reward_sum)
gif = False # Save only the first game of the evaluation as a gif
break
if len(eval_rewards) % 10 == 0:
print("Evaluation Completion: ",
str(evaluate_frame_number) + "/" + str(EVAL_STEPS))
print("Evaluation score:\n", np.mean(eval_rewards))
try:
utils.generate_gif(
frame_number, frames_for_gif, eval_rewards[0], args.gif_dir +
args.env_id + "/" + "seed_" + str(args.seed) + "/")
except IndexError:
print("No evaluation game finished")
logger.log("Average Evaluation Reward", np.mean(eval_rewards))
logger.log("Average Sequence Length",
evaluate_frame_number / len(eval_rewards))
# Save the network parameters
saver.save(sess,
args.checkpoint_dir + args.env_id + "/" + "seed_" +
str(args.seed) + "/" + 'model-',
global_step=frame_number)
print("Runtime: ", time.time() - start_time)
print("Epoch: ", epoch, "Total Frames: ", frame_number)
epoch += 1
logger.dumpkvs()
train_loader = DataLoader(trainset, shuffle=p.shuffle_dataset, batch_size=p.batch_size) # redefine train_loader to use data out.
val_loader = DataLoader(validset, shuffle=False, batch_size=p.test_batch_size)
masked_loader = DataLoader(maskedset, shuffle=False, batch_size=p.test_batch_size)
model.train()
first_batch_labels = torch.Tensor()
pred = torch.Tensor()
loss = []\\
for batch_n, batch in enumerate(train_loader):
batch = batch.to(device)
optimizer.zero_grad()
out, _ = model(batch)
labels = batch.y.to(device)
weights = generate_weights(labels).to(device)
tr_loss = F.binary_cross_entropy(out, target=labels, weight=weights)
loss.append(tr_loss.detach().item())
tr_loss.backward()
optimizer.step()
if batch_n == 0:
first_batch_labels = labels.clone().detach().to(device)
pred = out.clone().detach().round().to(device)
loss = mean(loss)
# -------------- EVALUATION & REPORTING ------------------------------------
roc_auc = roc_auc_score(first_batch_labels.cpu(), pred.cpu())
with torch.no_grad():
model.eval()
cum_pred = torch.Tensor().to(device)
WARNING this is a boilerplate model simply to get you started
with dSPP and structural propensities of proteins.
"""
model = Sequential()
model.add(Dense(args.maxlen, input_shape=(20*args.maxlen,), name="Prediction"))
print(model.summary())
return model
# all free parameters for the model
parameters = Struct(**{
"maxlen": 800,
})
X, Y = dspp.load_data()
weights = generate_weights(Y)
X = [lettercode2onehot(x) for x in X]
X = pad_sequences(X, 20*parameters.maxlen)
Y = pad_sequences(Y, parameters.maxlen, dtype='float32')
weights = pad_sequences(weights, parameters.maxlen, dtype='float32')
if __name__ == '__main__':
# Shuffle and split the data
(x_train, y_train, weights_train), (x_test, y_test, weights_test) = shuffle_and_split(X, Y, weights)
# Training parameters
batch_size = 128
epochs = 10
model = get_model(parameters)
