def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n([tf.nn.l2_loss(v) for v in self.weights.values()])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values() + self.biases.values())
grads = [g for g, v in grads_and_vars]
variables = [v for g, v in grads_and_vars]
# gradient clipping
# grads = [tf.clip_by_value(g, -2, 2) for g in grads]
# accumulate the grads
accum_grads_op = []
for i, accum_grad in enumerate(self.accum_grads.values()):
accum_grads_op.append(accum_grad.assign_add(grads[i]))
# pack accumulated gradient and vars back in grads_and_vars (while normalizing by policy_accum_steps)
grads_and_vars = []
for g, v in zip(self.accum_grads.values(), variables):
grads_and_vars.append([tf.div(g, self.solver_params['n_accum_steps']), v])
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w, accum_grads_op
def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n([tf.nn.l2_loss(v) for v in self.weights.values()])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values() + self.biases.values())
grads = [g for g, v in grads_and_vars]
variables = [v for g, v in grads_and_vars]
# gradient clipping
grads = [tf.clip_by_value(g, -2, 2) for g in grads]
# accumulate the grads
accum_grads_op = []
for i, accum_grad in enumerate(self.accum_grads.values()):
accum_grads_op.append(accum_grad.assign_add(grads[i]))
# pack accumulated gradient and vars back in grads_and_vars (while normalizing by policy_accum_steps)
grads_and_vars = []
for g, v in zip(self.accum_grads.values(), variables):
grads_and_vars.append([tf.div(g, self.solver_params['n_accum_steps']), v])
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w, accum_grads_op
def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.training_params['lr'])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values())
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w
def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.training_params['lr'])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values())
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w
def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n([tf.nn.l2_loss(v) for v in self.trainable_variables])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values() + self.biases.values())
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w
def backward(self, loss):
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n([tf.nn.l2_loss(v) for v in self.weights.values()])
# compute the gradients for a list of variables
grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.weights.values() + self.biases.values())
mean_abs_grad, mean_abs_w = common.compute_mean_abs_norm(grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(grads_and_vars)
return apply_grads, mean_abs_grad, mean_abs_w
def backward(self, loss):
# lr = self.learning_rate_func(self.iter, self.solver_params)
# self.iter += 1
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n([tf.nn.l2_loss(v) for v in self.trainable_variables])
# compute the gradients for a list of variables
self.grads_and_vars = opt.compute_gradients(loss=loss, var_list=self.trainable_variables)
self.mean_abs_grad, self.mean_abs_w = common.compute_mean_abs_norm(self.grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(self.grads_and_vars)
return apply_grads
def backward(self, loss):
# lr = self.learning_rate_func(self.iter, self.solver_params)
# self.iter += 1
# create an optimizer
opt = tf.train.AdamOptimizer(learning_rate=self.solver_params['lr'])
# weight decay
if self.solver_params['weight_decay']:
loss += self.solver_params['weight_decay'] * tf.add_n(
[tf.nn.l2_loss(v) for v in self.trainable_variables])
# compute the gradients for a list of variables
self.grads_and_vars = opt.compute_gradients(
loss=loss, var_list=self.trainable_variables)
self.mean_abs_grad, self.mean_abs_w = common.compute_mean_abs_norm(
self.grads_and_vars)
# apply the gradient
apply_grads = opt.apply_gradients(self.grads_and_vars)
return apply_grads
