in model/model.py [0:0]
def create_pathint_ops(self):
"""
Defines operations for path integral-based importance
Args:
Returns:
"""
reset_small_omega_ops = []
update_small_omega_ops = []
update_big_omega_ops = []
update_big_omega_riemann_ops = []
for v in range(len(self.trainable_vars)):
# Make sure that the variables are updated before calculating delta(theta)
with tf.control_dependencies([self.train]):
update_small_omega_ops.append(tf.assign_add(self.small_omega_vars[v],
-(self.vanilla_gradients_vars[v][0] * (self.trainable_vars[v] - self.weights_old[v]))))
# Ops to reset the small omega
reset_small_omega_ops.append(tf.assign(self.small_omega_vars[v], self.small_omega_vars[v]*0.0))
if self.imp_method == 'PI':
# Update the big omegas at the end of the task using the Eucldeian distance
update_big_omega_ops.append(tf.assign_add(self.big_omega_vars[v],
tf.nn.relu(tf.div(self.small_omega_vars[v], (PARAM_XI_STEP + tf.square(self.trainable_vars[v] - self.star_vars[v]))))))
elif self.imp_method == 'RWALK':
# Update the big omegas after small intervals using distance in riemannian manifold (KL-divergence)
update_big_omega_riemann_ops.append(tf.assign_add(self.big_omega_riemann_vars[v],
tf.nn.relu(tf.div(self.small_omega_vars[v],
(PARAM_XI_STEP + self.running_fisher_vars[v] * tf.square(self.trainable_vars[v] - self.weights_delta_old_vars[v]))))))
self.update_small_omega = tf.group(*update_small_omega_ops)
self.reset_small_omega = tf.group(*reset_small_omega_ops)
if self.imp_method == 'PI':
self.update_big_omega = tf.group(*update_big_omega_ops)
elif self.imp_method == 'RWALK':
self.update_big_omega_riemann = tf.group(*update_big_omega_riemann_ops)
self.big_omega_riemann_reset = [tf.assign(tensor, tf.zeros_like(tensor)) for tensor in self.big_omega_riemann_vars]
if self.imp_method == 'RWALK':
# For the first task, scale the scores so that division does not have an effect
self.scale_score = [tf.assign(s, s*2.0) for s in self.big_omega_riemann_vars]
# To reduce the rigidity after each task the importance scores are averaged
self.update_score = [tf.assign_add(scr, tf.div(tf.add(scr, riemm_omega), 2.0))
for scr, riemm_omega in zip(self.score_vars, self.big_omega_riemann_vars)]
# Get the min and max in each layer of the scores
self.get_max_score_vars = [tf.assign(var, tf.expand_dims(tf.squeeze(tf.reduce_max(scr, keepdims=True)),
axis=0)) for var, scr in zip(self.max_score_vars, self.score_vars)]
self.get_min_score_vars = [tf.assign(var, tf.expand_dims(tf.squeeze(tf.reduce_min(scr, keepdims=True)),
axis=0)) for var, scr in zip(self.min_score_vars, self.score_vars)]
self.max_score = tf.reduce_max(tf.convert_to_tensor(self.max_score_vars))
self.min_score = tf.reduce_min(tf.convert_to_tensor(self.min_score_vars))
with tf.control_dependencies([self.max_score, self.min_score]):
self.normalize_scores = [tf.assign(tgt, (var - self.min_score)/ (self.max_score - self.min_score + EPSILON))
for tgt, var in zip(self.normalized_score_vars, self.score_vars)]
# Sparsify all the layers except last layer
sparsify_score_ops = []
for v in range(len(self.normalized_score_vars) - 2):
sparsify_score_ops.append(tf.assign(self.normalized_score_vars[v],
tf.nn.dropout(self.normalized_score_vars[v], self.keep_prob)))
self.sparsify_scores = tf.group(*sparsify_score_ops)