def train_nn(pred_fun, loss_fun, num_weights, train_smiles, train_raw_targets, train_params, seed=0,
validation_smiles=None, validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print "Total number of weights in the network:", num_weights
init_weights = npr.RandomState(seed).randn(num_weights) * train_params['init_scale']
train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 10 == 0:
print "max of weights", np.max(np.abs(weights))
train_preds = undo_norm(pred_fun(weights, train_smiles))
cur_loss = loss_fun(weights, train_smiles, train_targets)
training_curve.append(cur_loss)
print "Iteration", iter, "loss", cur_loss, "train RMSE", rmse(train_preds, train_raw_targets),
if validation_smiles is not None:
validation_preds = undo_norm(pred_fun(weights, validation_smiles))
print "Validation RMSE", iter, ":", rmse(validation_preds, validation_raw_targets),
# Build gradient using autograd.
grad_fun = grad(loss_fun)
grad_fun_with_data = build_batched_grad(grad_fun, train_params['batch_size'],
train_smiles, train_targets)
# Optimize weights.
trained_weights = adam(grad_fun_with_data, init_weights, callback=callback,
num_iters=train_params['num_iters'], step_size=train_params['step_size'],
b1=train_params['b1'], b2=train_params['b2'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return undo_norm(pred_fun(trained_weights, new_smiles))
return predict_func, trained_weights, training_curve
def train_nn(pred_fun, loss_fun, num_weights, train_smiles, train_raw_targets, train_params,
validation_smiles=None, validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print "Total number of weights in the network:", num_weights
npr.seed(0)
init_weights = npr.randn(num_weights) * train_params['param_scale']
train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 10 == 0:
print "max of weights", np.max(np.abs(weights))
train_preds = undo_norm(pred_fun(weights, train_smiles))
cur_loss = loss_fun(weights, train_smiles, train_targets)
training_curve.append(cur_loss)
print "Iteration", iter, "loss", cur_loss, "train RMSE", \
np.sqrt(np.mean((train_preds - train_raw_targets)**2)),
if validation_smiles is not None:
validation_preds = undo_norm(pred_fun(weights, validation_smiles))
print "Validation RMSE", iter, ":", \
np.sqrt(np.mean((validation_preds - validation_raw_targets) ** 2)),
grad_fun = grad(loss_fun)
grad_fun_with_data = build_batched_grad(grad_fun, train_params['batch_size'],
train_smiles, train_targets)
num_iters = train_params['num_epochs'] * len(train_smiles) / train_params['batch_size']
trained_weights = adam(grad_fun_with_data, init_weights, callback=callback,
num_iters=num_iters, step_size=train_params['learn_rate'],
b1=train_params['b1'], b2=train_params['b2'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return undo_norm(pred_fun(trained_weights, new_smiles))
return predict_func, trained_weights, training_curve
def train_nn(pred_fun, loss_fun, num_weights, train_smiles, train_raw_targets, train_params, seed=0,
validation_smiles=None, validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print "Total number of weights in the network:", num_weights
init_weights = npr.RandomState(seed).randn(num_weights) * train_params['init_scale']
num_print_examples = 100
train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 10 == 0:
print "max of weights", np.max(np.abs(weights))
train_preds = undo_norm(pred_fun(weights, train_smiles[:num_print_examples]))
cur_loss = loss_fun(weights, train_smiles[:num_print_examples], train_targets[:num_print_examples])
training_curve.append(cur_loss)
print "Iteration", iter, "loss", cur_loss,\
"train RMSE", rmse(train_preds, train_raw_targets[:num_print_examples]),
if validation_smiles is not None:
validation_preds = undo_norm(pred_fun(weights, validation_smiles))
print "Validation RMSE", iter, ":", rmse(validation_preds, validation_raw_targets),
# Build gradient using autograd.
grad_fun = grad(loss_fun)
grad_fun_with_data = build_batched_grad(grad_fun, train_params['batch_size'],
train_smiles, train_targets)
# Optimize weights.
trained_weights = adam(grad_fun_with_data, init_weights, callback=callback,
num_iters=train_params['num_iters'], step_size=train_params['step_size'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return undo_norm(pred_fun(trained_weights, new_smiles))
return predict_func, trained_weights, training_curve
def train_nn(self,
pred_fun,
loss_fun,
num_weights,
train_smiles,
train_raw_targets,
train_params,
validation_smiles=None,
validation_raw_targets=None):
#def train_nn(self, pred_fun, loss_fun, num_weights, train_fps, train_raw_targets, train_params,
# validation_smiles=None, validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print "Total number of weights in the network:", num_weights
npr.seed(0)
init_weights = npr.randn(num_weights) * train_params['param_scale']
init_weights[-1] = self.other_param_dict['init_bias']
#train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 20 == 0:
print "max of weights", np.max(np.abs(weights))
#train_preds = undo_norm(pred_fun(weights, train_smiles))
cur_loss = loss_fun(weights, train_smiles, train_raw_targets)
#cur_loss = loss_fun(weights, train_fps, train_raw_targets)
training_curve.append(cur_loss)
print "Iteration", iter, "loss", cur_loss,
grad_fun = grad(loss_fun)
#grad_fun_with_data = build_batched_grad(grad_fun, train_params['batch_size'],
# train_fps, train_raw_targets)
grad_fun_with_data = build_batched_grad(grad_fun,
train_params['batch_size'],
train_smiles,
train_raw_targets)
#num_iters = train_params['num_epochs'] * np.shape(train_fps)[0] / train_params['batch_size']
num_iters = train_params['num_epochs'] * np.shape(
train_smiles)[0] / train_params['batch_size']
trained_weights = adam(grad_fun_with_data,
init_weights,
callback=callback,
num_iters=num_iters,
step_size=train_params['learn_rate'])
#b1=train_params['b1'], b2=train_params['b2'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return pred_fun(trained_weights, new_smiles)
def predict_func_fps(new_fps):
""" return function for fps """
return pred_fun(trained_weights, new_fps)
return predict_func, trained_weights, training_curve
def fit(self, smiles_list, logS_list, seed=0):
train_smiles = [smiles for smiles in smiles_list]
train_logS = [logS for logS in logS_list]
conv_layer_sizes = [self.model_params['conv_width']
] * self.model_params['fp_depth']
conv_arch_params = {
'num_hidden_features': conv_layer_sizes,
'fp_length': self.model_params['fp_length'],
'normalize': 1
}
# Neural net architecture
net_arch_params = dict(layer_sizes=[
self.model_params['fp_length'], self.model_params['h1_size']
],
normalize=True,
L2_reg=self.model_params['L2_reg'],
nll_func=rmse)
loss_fun, pred_fun, conv_parser = build_conv_deep_net(
conv_arch_params, net_arch_params, self.model_params['L2_reg'])
num_weights = len(conv_parser)
init_weights = npr.RandomState(seed).randn(
num_weights) * self.train_params['init_scale']
train_logS_norm, undo_norm = normalize_array(train_logS)
# Build gradient using autograd.
grad_fun = grad(loss_fun)
grad_fun_with_data = build_batched_grad(
grad_fun, self.train_params['batch_size'], train_smiles,
train_logS_norm)
# Optimize weights.
trained_weights = adam(grad_fun_with_data,
init_weights,
num_iters=self.train_params['num_iters'],
step_size=self.train_params['step_size'])
self.model = (undo_norm, trained_weights, pred_fun)
def train_nn(net_objects, smiles, raw_targets, callback, normalize_outputs,
seed, init_scale, batch_size, num_iters, **opt_params):
loss_fun, pred_fun, net_parser = net_objects
init_weights = init_scale * npr.RandomState(seed).randn(len(net_parser))
if normalize_outputs:
targets, undo_norm = normalize_array(raw_targets)
else:
targets, undo_norm = raw_targets, lambda x: x
def make_predict_func(new_weights):
return lambda new_smiles: undo_norm(pred_fun(new_weights, new_smiles))
def opt_callback(weights, i):
callback(make_predict_func(weights), i)
grad_fun = build_batched_grad(grad(loss_fun), batch_size, smiles, targets)
trained_weights = adam(grad_fun,
init_weights,
callback=opt_callback,
num_iters=num_iters,
**opt_params)
return trained_weights
def train_nn(pred_fun, loss_fun, num_weights, train_smiles, train_raw_targets, train_params, seed=0,
validation_smiles=None, validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print "Total number of weights in the network:", num_weights
init_weights = npr.RandomState(seed).randn(num_weights) * train_params['init_scale']
num_print_examples = 100
train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 10 == 0:
print "max of weights", np.max(np.abs(weights))
# import pdb; pdb.set_trace()
train_preds = undo_norm(pred_fun(weights, train_smiles[:num_print_examples]))
cur_loss = loss_fun(weights, train_smiles[:num_print_examples], train_targets[:num_print_examples]) # V: refers to line number #78 i.e.
# def loss_fun(weights, smiles, targets) of build_vanilla_net.py
training_curve.append(cur_loss)
print "Iteration", iter, "loss", cur_loss,\
"train RMSE", rmse(train_preds, train_raw_targets[:num_print_examples]),
if validation_smiles is not None:
validation_preds = undo_norm(pred_fun(weights, validation_smiles))
print "Validation RMSE", iter, ":", rmse(validation_preds, validation_raw_targets),
# Build gradient using autograd.
grad_fun = grad(loss_fun) # V: grad_fun acts as a gradient function which accept same arguments as that of loss_fun(Weights,Input,target) and,
# returns the gradient of weights for that sample (input, target)
# import pdb; pdb.set_trace()
grad_fun_with_data = build_batched_grad(grad_fun, train_params['batch_size'],
train_smiles, train_targets)
# Optimize weights.
trained_weights = adam(grad_fun_with_data, init_weights, callback=callback,
num_iters=train_params['num_iters'], step_size=train_params['step_size'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return undo_norm(pred_fun(trained_weights, new_smiles))
return predict_func, trained_weights, training_curve
def train_nn(pred_fun,
loss_fun,
nll_func_name,
nll_func,
num_weights,
train_smiles,
train_raw_targets,
train_params,
seed=0,
validation_smiles=None,
validation_raw_targets=None):
"""loss_fun has inputs (weights, smiles, targets)"""
print("Total number of weights in the network: {}".format(num_weights))
init_weights = npr.RandomState(seed).randn(
num_weights) * train_params['init_scale']
train_targets, undo_norm = normalize_array(train_raw_targets)
training_curve = []
def callback(weights, iter):
if iter % 10 == 0:
print("Iteration {}".format(iter))
print("\tmax of weights: {}".format(np.max(np.abs(weights))))
cur_loss = loss_fun(weights, train_smiles, train_targets)
training_curve.append(cur_loss)
print("\tloss {}".format(cur_loss))
train_preds = undo_norm(pred_fun(weights, train_smiles))
print("\ttrain {}: {}".format(
nll_func_name, nll_func(train_preds, train_raw_targets)))
if validation_smiles is not None:
validation_preds = undo_norm(
pred_fun(weights, validation_smiles))
print("\tvalidation {}: {}".format(
nll_func_name,
nll_func(validation_preds, validation_raw_targets)))
# Build gradient using autograd.
grad_fun = grad(loss_fun)
grad_fun_with_data = build_batched_grad(grad_fun,
train_params['batch_size'],
train_smiles, train_targets)
# Optimize weights.
trained_weights = adam(grad_fun_with_data,
init_weights,
callback=callback,
num_iters=train_params['num_iters'],
step_size=train_params['step_size'],
b1=train_params['b1'],
b2=train_params['b2'])
def predict_func(new_smiles):
"""Returns to the original units that the raw targets were in."""
return undo_norm(pred_fun(trained_weights, new_smiles))
return predict_func, trained_weights, training_curve