def measure_iterations(mf_initializer, guesses, molecules):
"""For an scf engine as returned by mf_initializer
for a list of molecules and a list of corresponding guesses the number
of required iterations will be returned.
"""
iterations = []
for i, (p, molecule) in enumerate(zip(guesses, molecules)):
msg.info("Iteration calculation: " + str(i))
mf = mf_initializer(molecule.get_pyscf_molecule())
try:
mf.kernel(dm0=p)
iterations.append(mf.iterations)
except Exception as ex:
msg.warn("SCF calculation failed: " + str(ex))
iterations.append(mf.max_cycle)
return iterations
def train_network(
network,
dataset,
sess=None,
learning_rate=0.001,
regularisation_parameter=0.01,
max_steps=100000,
evaluation_period=200,
mini_batch_size=0.2,
convergence_threshold=1e-5,
summary_save_path=None
):
"""Train a neural Neutwork from nn.networks with the AdamOptimizer,
to minimize the mean squared error with l2 regularisation.
Args:
- network <nn.networks.AbstractNeuralNetwork>: the network to be trained.
- dataset <utilities.dataset.Dataset>: the dataset to train the net on.
- learning_rate <float>: the learning rate to use for training w/
AdamOptimizer
- regularisation_parameter <float>: the factor with which the
regularisation is added to the total cost.
- max_steps <int>: max number of learning steps to take if convergence
not met before.
- evaluation_period <int>: period of training steps after which there
will be a check for convergence.
mini_batch_size <int>: size of the minibatch that is randomly sampled
from the training dataset in every training step.
- convergence_threshold <float>: training convergence is reached if
difference in error drops below this value.
- summary_save_path <str>: the full path to a folder in which the
tensorboard data will be written. If None given nothing will be exported.
Returns:
- the trained network
- the session
"""
if sess is None:
sess = tf.Session()
#--- set up the graph ---
msg.info("Setting up the graph ...", 1)
network_output = network.setup()
x = network.input_tensor
y = tf.placeholder(
dtype="float32",
shape=[None, network.structure[-1]],
name="y"
)
# cost is mse w/ l2 regularisation
cost, mse, _ = mse_with_l2_regularisation(
network,
expectation_tensor=y,
regularisation_parameter=regularisation_parameter
)
#optimizer and training
with tf.name_scope("training"):
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_step = optimizer.minimize(cost)
#---
#--- prep the writer ---
if not summary_save_path is None:
msg.warn("Careful! If more than 1 network is in current graph, " + \
"it should be cleared before merging the summary!"
)
summary = tf.summary.merge_all()
writer = tf.summary.FileWriter(summary_save_path)
writer.add_graph(sess.graph)
#---
#--- train the network ---
msg.info("Starting network training ...", 1)
old_error = 1e10
sess.run(tf.global_variables_initializer())
for step in range(max_steps):
mini_batch = dataset.sample_minibatch(mini_batch_size)
if step % np.ceil(evaluation_period / 10) == 0:
if not summary_save_path is None:
writer.add_summary(
sess.run(
summary,
feed_dict={
x: mini_batch[0],
y: mini_batch[1]
}
),
step
)
if step % evaluation_period == 0:
error = sess.run(
mse,
feed_dict={x: dataset.validation[0], y: dataset.validation[1]}
)
# compare to previous error
diff = np.abs(error - old_error)
# convergence check
if diff < convergence_threshold:
msg.info(
"Convergence reached after " + str(step) + " steps.",
1
)
break
else:
msg.info(
"Validation cost: {:0.5E}. Diff to prev.: {:0.1E}".format(
error,
diff
)
)
old_error = error
# do training step
sess.run(train_step, feed_dict={x: mini_batch[0], y: mini_batch[1]})
#---
if not summary_save_path is None:
writer.close()
test_error = sess.run(
mse,
feed_dict={x: dataset.testing[0], y: dataset.testing[1]}
)
msg.info("Test error: {:0.5E}".format(test_error), 1)
return network, sess