def main():
input_sequences = [
"SRSLVISTINQISEDSKEFYFTLDNGKTMFPSNSQAWGGEKFENGQRAFVIFNELEQPVNGYDYNIQVRDITKVLTKEIVTMDDEE" \
"NTEEKIGDDKINATYMWISKDKKYLTIEFQYYSTHSEDKKHFLNLVINNKDNTDDEYINLEFRHNSERDSPDHLGEGYVSFKLDKI" \
"EEQIEGKKGLNIRVRTLYDGIKNYKVQFP"]
model_path = "output/models/2019-01-30_00_38_46-TRAIN-LR0_01-MB1.model"
model = torch.load(model_path)
input_sequences_encoded = list(
torch.LongTensor(encode_primary_string(aa)) for aa in input_sequences)
predicted_dihedral_angles, _predicted_backbone_atoms, _batch_sizes = \
model(input_sequences_encoded)
write_to_pdb(
get_structure_from_angles(input_sequences_encoded[0],
predicted_dihedral_angles[:, 0]),
"myprediction")
print("Wrote prediction to output/protein_myprediction.pdb")
def prediction():
list_of_files = glob.glob('output/models/*')
default_model_path = max(list_of_files, key=os.path.getctime)
parser = argparse.ArgumentParser(
description="OpenProtein - Prediction CLI")
parser.add_argument('--input_sequence', dest='input_sequence')
parser.add_argument('--model_path',
dest='model_path',
default=default_model_path)
parser.add_argument('--use_gpu', dest='use_gpu', default=False, type=bool)
args, _ = parser.parse_known_args()
print("Using model:", args.model_path)
model = torch.load(args.model_path)
input_sequences = [args.input_sequence]
input_sequences_encoded = list(
torch.IntTensor(encode_primary_string(aa)) for aa in input_sequences)
predicted_dihedral_angles, predicted_backbone_atoms, batch_sizes = \
model(input_sequences_encoded)
if predicted_dihedral_angles == []:
predicted_dihedral_angles, _ = calculate_dihedral_angles_over_minibatch(
predicted_backbone_atoms, batch_sizes, args.use_gpu)
write_to_pdb(
get_structure_from_angles(input_sequences_encoded[0],
predicted_dihedral_angles[:, 0]),
"prediction")
print("Wrote prediction to output/protein_prediction.pdb")
def train_model(data_set_identifier, train_file, val_file, learning_rate, minibatch_size, name):
set_experiment_id(data_set_identifier, learning_rate, minibatch_size, name)
train_loader = contruct_dataloader_from_disk(train_file, minibatch_size, use_evolutionary=True)
validation_loader = contruct_dataloader_from_disk(val_file, minibatch_size, use_evolutionary=True)
validation_dataset_size = validation_loader.dataset.__len__()
train_dataset_size = train_loader.dataset.__len__()
embedding_size = 21
if configs.run_params["use_evolutionary"]:
embedding_size = 42
#Load in existing model if given as argument
if args.model is not None:
model_path = "output/models/" + args.model + ".model"
model = load_model_from_disk(model_path, use_gpu)
else:
#else construct new model from config file
model = construct_model(configs.model_params, embedding_size, use_gpu,minibatch_size)
#optimizer parameters
betas = tuple(configs.run_params["betas"])
weight_decay = configs.run_params["weight_decay"]
angle_lr = configs.run_params["angles_lr"]
if configs.model_params['architecture'] == 'cnn_angles':
optimizer = optim.Adam(model.parameters(), betas=betas, lr=learning_rate, weight_decay=weight_decay)
else:
optimizer = optim.Adam([
{'params' : model.model.parameters(), 'lr':learning_rate},
{'params' : model.soft_to_angle.parameters(), 'lr':angle_lr}], betas=betas, weight_decay=weight_decay)
#print number of trainable parameters
print_number_of_parameters(model)
#For creating a summary table of the model (does not work on ExampleModel!)
if configs.run_params["print_model_summary"]:
if configs.model_params["architecture"] != 'rnn':
summary(model, configs.run_params["max_sequence_length"], 2)
else:
write_out("DETAILED MODEL SUMMARY IS NOT SUPPORTED FOR RNN MODELS")
if use_gpu:
model = model.cuda()
# TODO: is soft_to_angle.parameters() included here?
sample_num = list()
train_loss_values = list()
validation_loss_values = list()
rmsd_avg_values = list()
drmsd_avg_values = list()
break_point_values = list()
breakpoints = configs.run_params['breakpoints']
best_model_loss = 1e20
best_model_train_loss = 1e20
best_model_minibatch_time = None
best_model_path = None
stopping_condition_met = False
minibatches_proccesed = 0
loss_atoms = configs.run_params["loss_atoms"]
start_time = time.time()
max_time = configs.run_params["max_time"]
C_epochs = configs.run_params["c_epochs"] # TODO: Change to parameter
C_batch_updates = C_epochs
while not stopping_condition_met:
optimizer.zero_grad()
model.zero_grad()
loss_tracker = np.zeros(0)
start_time_n_minibatches = time.time()
for minibatch_id, training_minibatch in enumerate(train_loader, 0):
minibatches_proccesed += 1
training_minibatch = list(training_minibatch)
primary_sequence, tertiary_positions, mask, p_id = training_minibatch[:-1]
# Update C
C = 1.0 if minibatches_proccesed >= C_batch_updates else float(minibatches_proccesed) / C_batch_updates
#One Hot encode amino string and concate PSSM values.
amino_acids, batch_sizes = one_hot_encode(primary_sequence, 21, use_gpu)
if configs.run_params["use_evolutionary"]:
evolutionary = training_minibatch[-1]
evolutionary, batch_sizes = torch.nn.utils.rnn.pad_packed_sequence(torch.nn.utils.rnn.pack_sequence(evolutionary))
if use_gpu:
evolutionary = evolutionary.cuda()
amino_acids = torch.cat((amino_acids, evolutionary.view(-1, len(batch_sizes) , 21)), 2)
start_compute_loss = time.time()
if configs.run_params["only_angular_loss"]:
#raise NotImplementedError("Only_angular_loss function has not been implemented correctly yet.")
loss = model.compute_angular_loss((amino_acids, batch_sizes), tertiary_positions, mask)
else:
loss = model.compute_loss((amino_acids, batch_sizes), tertiary_positions, mask, C=C, loss_atoms=loss_atoms)
if C != 1:
write_out("C:", C)
write_out("Train loss:", float(loss))
start_compute_grad = time.time()
loss.backward()
loss_tracker = np.append(loss_tracker, float(loss))
end = time.time()
write_out("Loss time:", start_compute_grad-start_compute_loss, "Grad time:", end-start_compute_grad)
optimizer.step()
optimizer.zero_grad()
model.zero_grad()
# for every eval_interval samples, plot performance on the validation set
if minibatches_proccesed % configs.run_params["eval_interval"] == 0:
model.eval()
write_out("Testing model on validation set...")
train_loss = loss_tracker.mean()
loss_tracker = np.zeros(0)
validation_loss, data_total, rmsd_avg, drmsd_avg = evaluate_model(validation_loader,
model, use_gpu, loss_atoms, configs.run_params["use_evolutionary"])
prim = data_total[0][0]
pos = data_total[0][1]
pos_pred = data_total[0][3]
mask = data_total[0][4]
pos = apply_mask(pos, mask)
angles_pred = data_total[0][2]
angles_pred = apply_mask(angles_pred, mask, size=3)
pos_pred = apply_mask(pos_pred, mask)
prim = torch.masked_select(prim, mask)
if use_gpu:
pos = pos.cuda()
pos_pred = pos_pred.cuda()
angles = calculate_dihedral_angels(pos, use_gpu)
#angles_pred = calculate_dihedral_angels(pos_pred, use_gpu)
#angles_pred = data_total[0][2] # Use angles output from model - calculate_dihedral_angels(pos_pred, use_gpu)
write_to_pdb(get_structure_from_angles(prim, angles), "test")
write_to_pdb(get_structure_from_angles(prim, angles_pred), "test_pred")
if validation_loss < best_model_loss:
best_model_loss = validation_loss
best_model_minibatch_time = minibatches_proccesed
best_model_path = write_model_to_disk(model)
if train_loss < best_model_train_loss:
best_model_train_loss = train_loss
best_model_train_path = write_model_to_disk(model, model_type="train")
write_out("Validation loss:", validation_loss, "Train loss:", train_loss)
write_out("Best model so far (validation loss): ", best_model_loss, "at time", best_model_minibatch_time)
write_out("Best model stored at " + best_model_path)
write_out("Best model train stored at " + best_model_train_path)
write_out("Minibatches processed:",minibatches_proccesed)
end_time_n_minibatches = time.time()
n_minibatches_time_used = end_time_n_minibatches - start_time_n_minibatches
minibatches_left = configs.run_params["max_updates"] - minibatches_proccesed
seconds_left = int(n_minibatches_time_used * (minibatches_left/configs.run_params["eval_interval"]))
m, s = divmod(seconds_left, 60)
h, m = divmod(m, 60)
write_out("Estimated time until maximum number of updates:", '{:d}:{:02d}:{:02d}'.format(h, m, s) )
sample_num.append(minibatches_proccesed)
train_loss_values.append(train_loss)
validation_loss_values.append(validation_loss)
rmsd_avg_values.append(rmsd_avg)
drmsd_avg_values.append(drmsd_avg)
if breakpoints and minibatches_proccesed > breakpoints[0]:
break_point_values.append(drmsd_avg)
breakpoints = breakpoints[1:]
data = {}
data["pdb_data_pred"] = open("output/protein_test_pred.pdb","r").read()
data["pdb_data_true"] = open("output/protein_test.pdb","r").read()
data["validation_dataset_size"] = validation_dataset_size
data["sample_num"] = sample_num
data["train_loss_values"] = train_loss_values
data["break_point_values"] = break_point_values
data["validation_loss_values"] = validation_loss_values
data["phi_actual"] = list([math.degrees(float(v)) for v in angles[1:,1]])
data["psi_actual"] = list([math.degrees(float(v)) for v in angles[:-1,2]])
data["phi_predicted"] = list([math.degrees(float(v)) for v in angles_pred[1:,1]])
data["psi_predicted"] = list([math.degrees(float(v)) for v in angles_pred[:-1,2]])
data["drmsd_avg"] = drmsd_avg_values
data["rmsd_avg"] = rmsd_avg_values
if not configs.run_params["hide_ui"]:
res = requests.post('http://localhost:5000/graph', json=data)
if res.ok:
print(res.json())
# Save run data
write_run_to_disk(data)
#Check if maximum time is reached.
start_time_n_minibatches = time.time()
time_used = time.time() - start_time
time_condition = (max_time is not None and time_used > max_time)
max_update_condition = minibatches_proccesed >= configs.run_params["max_updates"]
min_update_condition = (minibatches_proccesed > configs.run_params["min_updates"] and minibatches_proccesed > best_model_minibatch_time * 2)
model.train()
#Checking for stop conditions
if time_condition or max_update_condition or min_update_condition:
stopping_condition_met = True
break
write_out("Best validation model found after" , best_model_minibatch_time , "minibatches.")
write_result_summary(best_model_loss)
return best_model_path
def evaluate_model(self, data_loader):
loss = 0
data_total = []
dRMSD_list = []
RMSD_list = []
for _, data in enumerate(data_loader, 0):
primary_sequence, tertiary_positions, _mask = data
start = time.time()
predicted_angles, backbone_atoms, batch_sizes = self(primary_sequence)
write_out("Apply model to validation minibatch:", time.time() - start)
if predicted_angles == []:
# model didn't provide angles, so we'll compute them here
output_angles, _ = calculate_dihedral_angles_over_minibatch(backbone_atoms,
batch_sizes,
self.use_gpu)
else:
output_angles = predicted_angles
cpu_predicted_angles = output_angles.transpose(0, 1).cpu().detach()
if backbone_atoms == []:
# model didn't provide backbone atoms, we need to compute that
output_positions, _ = \
get_backbone_positions_from_angles(predicted_angles,
batch_sizes,
self.use_gpu)
else:
output_positions = backbone_atoms
cpu_predicted_backbone_atoms = output_positions.transpose(0, 1).cpu().detach()
minibatch_data = list(zip(primary_sequence,
tertiary_positions,
cpu_predicted_angles,
cpu_predicted_backbone_atoms))
data_total.extend(minibatch_data)
start = time.time()
for primary_sequence, tertiary_positions, _predicted_pos, predicted_backbone_atoms\
in minibatch_data:
actual_coords = tertiary_positions.transpose(0, 1).contiguous().view(-1, 3)
predicted_coords = predicted_backbone_atoms[:len(primary_sequence)]\
.transpose(0, 1).contiguous().view(-1, 3).detach()
rmsd = calc_rmsd(predicted_coords, actual_coords)
drmsd = calc_drmsd(predicted_coords, actual_coords)
RMSD_list.append(rmsd)
dRMSD_list.append(drmsd)
error = rmsd
loss += error
end = time.time()
write_out("Calculate validation loss for minibatch took:", end - start)
loss /= data_loader.dataset.__len__()
self.historical_rmsd_avg_values.append(float(torch.Tensor(RMSD_list).mean()))
self.historical_drmsd_avg_values.append(float(torch.Tensor(dRMSD_list).mean()))
prim = data_total[0][0]
pos = data_total[0][1]
pos_pred = data_total[0][3]
if self.use_gpu:
pos = pos.cuda()
pos_pred = pos_pred.cuda()
angles = calculate_dihedral_angles(pos, self.use_gpu)
angles_pred = calculate_dihedral_angles(pos_pred, self.use_gpu)
write_to_pdb(get_structure_from_angles(prim, angles), "test")
write_to_pdb(get_structure_from_angles(prim, angles_pred), "test_pred")
data = {}
data["pdb_data_pred"] = open("output/protein_test_pred.pdb", "r").read()
data["pdb_data_true"] = open("output/protein_test.pdb", "r").read()
data["phi_actual"] = list([math.degrees(float(v)) for v in angles[1:, 1]])
data["psi_actual"] = list([math.degrees(float(v)) for v in angles[:-1, 2]])
data["phi_predicted"] = list([math.degrees(float(v)) for v in angles_pred[1:, 1]])
data["psi_predicted"] = list([math.degrees(float(v)) for v in angles_pred[:-1, 2]])
data["rmsd_avg"] = self.historical_rmsd_avg_values
data["drmsd_avg"] = self.historical_drmsd_avg_values
prediction_data = None
return (loss, data, prediction_data)
def train_model(data_set_identifier, train_file, val_file, learning_rate,
minibatch_size):
set_experiment_id(data_set_identifier, learning_rate, minibatch_size)
train_loader = contruct_dataloader_from_disk(train_file, minibatch_size)
validation_loader = contruct_dataloader_from_disk(val_file, minibatch_size)
validation_dataset_size = validation_loader.dataset.__len__()
model = ExampleModel(21, minibatch_size,
use_gpu=use_gpu) # embed size = 21
# TODO: is soft_to_angle.parameters() included here?
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
sample_num = list()
train_loss_values = list()
validation_loss_values = list()
rmsd_avg_values = list()
drmsd_avg_values = list()
best_model_loss = 1.1
best_model_minibatch_time = None
best_model_path = None
stopping_condition_met = False
minibatches_proccesed = 0
while not stopping_condition_met:
optimizer.zero_grad()
model.zero_grad()
loss_tracker = np.zeros(0)
for minibatch_id, training_minibatch in enumerate(train_loader, 0):
minibatches_proccesed += 1
primary_sequence, tertiary_positions, mask = training_minibatch
start_compute_loss = time.time()
loss = model.compute_loss(primary_sequence, tertiary_positions)
write_out("Train loss:", float(loss))
start_compute_grad = time.time()
loss.backward()
loss_tracker = np.append(loss_tracker, float(loss))
end = time.time()
write_out("Loss time:", start_compute_grad - start_compute_loss,
"Grad time:", end - start_compute_grad)
optimizer.step()
optimizer.zero_grad()
model.zero_grad()
# for every eval_interval samples, plot performance on the validation set
if minibatches_proccesed % args.eval_interval == 0:
train_loss = loss_tracker.mean()
loss_tracker = np.zeros(0)
validation_loss, data_total, rmsd_avg, drmsd_avg = evaluate_model(
validation_loader, model)
prim = data_total[0][0]
pos = data_total[0][1]
(aa_list, phi_list, psi_list,
omega_list) = calculate_dihedral_angels(prim, pos)
write_to_pdb(
get_structure_from_angles(aa_list, phi_list[1:],
psi_list[:-1], omega_list[:-1]),
"test")
cmd.load("output/protein_test.pdb")
write_to_pdb(data_total[0][3], "test_pred")
cmd.load("output/protein_test_pred.pdb")
cmd.forward()
cmd.orient()
if validation_loss < best_model_loss:
best_model_loss = validation_loss
best_model_minibatch_time = minibatches_proccesed
best_model_path = write_model_to_disk(model)
write_out("Validation loss:", validation_loss, "Train loss:",
train_loss)
write_out("Best model so far (label loss): ", validation_loss,
"at time", best_model_minibatch_time)
write_out("Best model stored at " + best_model_path)
write_out("Minibatches processed:", minibatches_proccesed)
sample_num.append(minibatches_proccesed)
train_loss_values.append(train_loss)
validation_loss_values.append(validation_loss)
rmsd_avg_values.append(rmsd_avg)
drmsd_avg_values.append(drmsd_avg)
if args.live_plot:
data = {}
data["validation_dataset_size"] = validation_dataset_size
data["sample_num"] = sample_num
data["train_loss_values"] = train_loss_values
data["validation_loss_values"] = validation_loss_values
data["phi_actual"] = list(
[math.degrees(float(v)) for v in phi_list[1:]])
data["psi_actual"] = list(
[math.degrees(float(v)) for v in psi_list[:-1]])
data["phi_predicted"] = list([
math.degrees(float(v)) for v in data_total[0]
[2].detach().transpose(0, 1)[0][1:]
])
data["psi_predicted"] = list([
math.degrees(float(v)) for v in data_total[0]
[2].detach().transpose(0, 1)[1][:-1]
])
data["drmsd_avg"] = drmsd_avg_values
data["rmsd_avg"] = rmsd_avg_values
res = requests.post('http://localhost:5000/graph',
json=data)
if res.ok:
print(res.json())
if minibatches_proccesed > args.minimum_updates and minibatches_proccesed > best_model_minibatch_time * 2:
stopping_condition_met = True
break
write_result_summary(best_model_loss)
return best_model_path
def evaluate_model(self, data_loader):
loss = 0
angular_loss = 0
data_total = []
dRMSD_list = []
RMSD_list = []
for _, data in enumerate(data_loader, 0):
primary_sequence, tertiary_positions, _mask, pssm, token = data
start = time.time()
predicted_angles, backbone_atoms, _batch_sizes = self(
primary_sequence, pssm, token)
write_out("Apply model to validation minibatch:",
time.time() - start)
cpu_predicted_angles = predicted_angles.transpose(
0, 1).cpu().detach()
cpu_predicted_backbone_atoms = backbone_atoms.transpose(
0, 1).cpu().detach()
minibatch_data = list(
zip(primary_sequence, tertiary_positions, cpu_predicted_angles,
cpu_predicted_backbone_atoms))
data_total.extend(minibatch_data)
actual_coords_list_padded, batch_sizes_coords = torch.nn.utils.rnn.pad_packed_sequence(
torch.nn.utils.rnn.pack_sequence(tertiary_positions))
if self.use_gpu:
actual_coords_list_padded = actual_coords_list_padded.cuda()
emissions_actual, _ = calculate_dihedral_angles_over_minibatch(
actual_coords_list_padded, batch_sizes_coords, self.use_gpu)
start = time.time()
for primary_sequence, tertiary_positions, _predicted_pos, predicted_backbone_atoms \
in minibatch_data:
actual_coords = tertiary_positions.transpose(
0, 1).contiguous().view(-1, 3)
predicted_coords = predicted_backbone_atoms[:len(primary_sequence)] \
.transpose(0, 1).contiguous().view(-1, 3).detach()
if self.use_gpu:
emissions_actual = emissions_actual.cuda()
angular_loss += float(
calc_angular_difference(predicted_angles,
emissions_actual))
rmsd = calc_rmsd(predicted_coords, actual_coords)
drmsd = calc_drmsd(predicted_coords, actual_coords)
RMSD_list.append(rmsd)
dRMSD_list.append(drmsd)
error = float(drmsd)
loss += error
end = time.time()
write_out("Calculate validation loss for minibatch took:",
end - start)
loss /= data_loader.dataset.__len__()
angular_loss /= data_loader.dataset.__len__()
self.historical_rmsd_avg_values.append(
float(torch.Tensor(RMSD_list).mean()))
self.historical_drmsd_avg_values.append(
float(torch.Tensor(dRMSD_list).mean()))
prim = data_total[0][0]
pos = data_total[0][1]
pos_pred = data_total[0][3]
if self.use_gpu:
pos = pos.cuda()
pos_pred = pos_pred.cuda()
angles = calculate_dihedral_angles(pos, self.use_gpu)
angles_pred = calculate_dihedral_angles(pos_pred, self.use_gpu)
write_to_pdb(get_structure_from_angles(prim, angles), "test")
write_to_pdb(get_structure_from_angles(prim, angles_pred), "test_pred")
data = {}
data["pdb_data_pred"] = open("output/protein_test_pred.pdb",
"r").read()
data["pdb_data_true"] = open("output/protein_test.pdb", "r").read()
data["phi_actual"] = list(
[math.degrees(float(v)) for v in angles[1:, 1]])
data["psi_actual"] = list(
[math.degrees(float(v)) for v in angles[:-1, 2]])
data["phi_predicted"] = list(
[math.degrees(float(v)) for v in angles_pred[1:, 1]])
data["psi_predicted"] = list(
[math.degrees(float(v)) for v in angles_pred[:-1, 2]])
data["rmsd_avg"] = self.historical_rmsd_avg_values
data["drmsd_avg"] = self.historical_drmsd_avg_values
prediction_data = None
return loss, data, prediction_data, angular_loss
# This file is part of the OpenProtein project.
#
# @author Jeppe Hallgren
#
# For license information, please see the LICENSE file in the root directory.
import torch
from util import encode_primary_string, get_structure_from_angles, write_to_pdb, \
calculate_dihedral_angles_over_minibatch
input_sequences = [
"SRSLVISTINQISEDSKEFYFTLDNGKTMFPSNSQAWGGEKFENGQRAFVIFNELEQPVNGYDYNIQVRDITKVLTKEIVTMDDEENTEEKIGDDKINATYMWISKDKKYLTIEFQYYSTHSEDKKHFLNLVINNKDNTDDEYINLEFRHNSERDSPDHLGEGYVSFKLDKIEEQIEGKKGLNIRVRTLYDGIKNYKVQFP"
]
model_path = "output/models/2019-01-30_00_38_46-TRAIN-LR0_01-MB1.model"
model = torch.load(model_path)
input_senquences_encoded = list(
torch.LongTensor(encode_primary_string(aa)) for aa in input_sequences)
predicted_dihedral_angles, predicted_backbone_atoms, batch_sizes = model(
input_senquences_encoded)
write_to_pdb(
get_structure_from_angles(input_senquences_encoded[0],
predicted_dihedral_angles[:, 0]), "myprediction")
print("Wrote prediction to output/protein_myprediction.pdb")
def train_model(data_set_identifier, train_file, val_file, learning_rate,
minibatch_size):
set_experiment_id(data_set_identifier, learning_rate, minibatch_size)
train_loader = contruct_dataloader_from_disk(train_file, minibatch_size)
validation_loader = contruct_dataloader_from_disk(val_file, minibatch_size)
validation_dataset_size = validation_loader.dataset.__len__()
model = ExampleModel(21, minibatch_size,
use_gpu=use_gpu) # embed size = 21
if use_gpu:
model = model.cuda()
# TODO: is soft_to_angle.parameters() included here?
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
sample_num = list()
train_loss_values = list()
validation_loss_values = list()
rmsd_avg_values = list()
drmsd_avg_values = list()
best_model_loss = 1e20
best_model_minibatch_time = None
best_model_path = None
stopping_condition_met = False
minibatches_proccesed = 0
while not stopping_condition_met:
optimizer.zero_grad()
model.zero_grad()
loss_tracker = np.zeros(0)
for minibatch_id, training_minibatch in enumerate(train_loader, 0):
minibatches_proccesed += 1
primary_sequence, tertiary_positions, mask = training_minibatch
start_compute_loss = time.time()
loss = model.compute_loss(primary_sequence, tertiary_positions)
write_out("Train loss:", float(loss))
start_compute_grad = time.time()
loss.backward()
loss_tracker = np.append(loss_tracker, float(loss))
end = time.time()
write_out("Loss time:", start_compute_grad - start_compute_loss,
"Grad time:", end - start_compute_grad)
optimizer.step()
optimizer.zero_grad()
model.zero_grad()
# for every eval_interval samples, plot performance on the validation set
if minibatches_proccesed % args.eval_interval == 0:
write_out("Testing model on validation set...")
train_loss = loss_tracker.mean()
loss_tracker = np.zeros(0)
validation_loss, data_total, rmsd_avg, drmsd_avg = evaluate_model(
validation_loader, model)
prim = data_total[0][0]
pos = data_total[0][1]
pos_pred = data_total[0][3]
if use_gpu:
pos = pos.cuda()
pos_pred = pos_pred.cuda()
angles = calculate_dihedral_angels(pos, use_gpu)
angles_pred = calculate_dihedral_angels(pos_pred, use_gpu)
write_to_pdb(get_structure_from_angles(prim, angles), "test")
write_to_pdb(get_structure_from_angles(prim, angles_pred),
"test_pred")
if validation_loss < best_model_loss:
best_model_loss = validation_loss
best_model_minibatch_time = minibatches_proccesed
best_model_path = saveModel(encoder_net, decoder_net,
encoder_optimizer,
decoder_optimizer, loss.item(),
tot_eval_acc, e)
write_out("Validation loss:", validation_loss, "Train loss:",
train_loss)
write_out("Best model so far (validation loss): ",
validation_loss, "at time",
best_model_minibatch_time)
write_out("Best model stored at " + best_model_path)
write_out("Minibatches processed:", minibatches_proccesed)
sample_num.append(minibatches_proccesed)
train_loss_values.append(train_loss)
validation_loss_values.append(validation_loss)
rmsd_avg_values.append(rmsd_avg)
drmsd_avg_values.append(drmsd_avg)
if not args.hide_ui:
data = {}
data["pdb_data_pred"] = open(
"output/protein_test_pred.pdb", "r").read()
data["pdb_data_true"] = open("output/protein_test.pdb",
"r").read()
data["validation_dataset_size"] = validation_dataset_size
data["sample_num"] = sample_num
data["train_loss_values"] = train_loss_values
data["validation_loss_values"] = validation_loss_values
data["phi_actual"] = list(
[math.degrees(float(v)) for v in angles[1:, 1]])
data["psi_actual"] = list(
[math.degrees(float(v)) for v in angles[:-1, 2]])
data["phi_predicted"] = list(
[math.degrees(float(v)) for v in angles_pred[1:, 1]])
data["psi_predicted"] = list(
[math.degrees(float(v)) for v in angles_pred[:-1, 2]])
data["drmsd_avg"] = drmsd_avg_values
data["rmsd_avg"] = rmsd_avg_values
res = requests.post('http://localhost:5000/graph',
json=data)
if res.ok:
print(res.json())
if minibatches_proccesed > args.minimum_updates and minibatches_proccesed > best_model_minibatch_time * 2:
stopping_condition_met = True
break
write_result_summary(best_model_loss)
return best_model_path
