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))
# 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
