如何在 Tensorflow 中设置分层学习率？

Posted 2023-03-15

【中文标题】如何在 Tensorflow 中设置分层学习率？

【英文标题】：How to set layer-wise learning rate in Tensorflow?

【发布时间】：2016-04-28 23:38:53

【问题描述】：

我想知道是否有一种方法可以对不同的层使用不同的学习率，就像 Caffe 中的一样。我正在尝试修改预训练模型并将其用于其他任务。我想要的是加快新添加层的训练，并使训练后的层保持低学习率，以防止它们被扭曲。例如，我有一个 5 层的预训练模型。现在我添加一个新的卷积层并对其进行微调。前 5 层的学习率为 0.00001，最后一层的学习率为 0.001。知道如何实现这一目标吗？

【问题讨论】：

TF 1.8 的tf.custom_gradient 现在大大简化了这个问题——请看下面我的回答。

对于 TF2：tensorflow.org/addons/api_docs/python/tfa/optimizers/…

【参考方案1】：

使用 2 个优化器可以很容易地实现：

var_list1 = [variables from first 5 layers]
var_list2 = [the rest of variables]
train_op1 = GradientDescentOptimizer(0.00001).minimize(loss, var_list=var_list1)
train_op2 = GradientDescentOptimizer(0.0001).minimize(loss, var_list=var_list2)
train_op = tf.group(train_op1, train_op2)

这种实现的一个缺点是它在优化器中计算 tf.gradients(.) 两次，因此它在执行速度方面可能不是最优的。这可以通过显式调用 tf.gradients(.)、将列表拆分为 2 并将相应的梯度传递给两个优化器来缓解。

相关问题：Holding variables constant during optimizer

编辑：添加了更高效但更长的实现：

var_list1 = [variables from first 5 layers]
var_list2 = [the rest of variables]
opt1 = tf.train.GradientDescentOptimizer(0.00001)
opt2 = tf.train.GradientDescentOptimizer(0.0001)
grads = tf.gradients(loss, var_list1 + var_list2)
grads1 = grads[:len(var_list1)]
grads2 = grads[len(var_list1):]
tran_op1 = opt1.apply_gradients(zip(grads1, var_list1))
train_op2 = opt2.apply_gradients(zip(grads2, var_list2))
train_op = tf.group(train_op1, train_op2)

您可以使用tf.trainable_variables() 获取所有训练变量并决定从中进行选择。 不同之处在于，在第一个实现中，tf.gradients(.) 在优化器中被调用了两次。这可能会导致执行一些冗余操作（例如，第一层的梯度可以重用一些计算来用于后续层的梯度）。

【讨论】：

感谢您的回答拉法尔。当你说它在速度方面的劣势时，我仍然有点想知道它会对性能产生多大的影响。如果我正在训练一个大型网络，如果这是一个很大的负担，那将不是一个好的选择。此外，您能否更具体地说明您的第二种方法？如何显式调用 tf.gradients()？对不起，我还是个新手。

thx 伙计，倒数第二行应该是“train_op2 = opt2.apply_gradients(.)”吗？如果我理解正确的话。

在您的第一个示例中，您在minimize 中使用了loss，所以我认为您的第二个示例应该使用tf.gradients(loss, var_list1 + var_list2)

有什么原因不能扩展到 3 个或更多单独的列表？

另外，如果我在apply_gradients 中使用global_step，你会将它用于opt1 和opt2，还是只在最后一个apply_gradients 上使用它？

【参考方案2】：

Tensorflow 1.7 引入了tf.custom_gradient，它极大地简化了学习率乘数的设置，现在它与任何优化器兼容，包括那些累积梯度统计的优化器。例如，

import tensorflow as tf

def lr_mult(alpha):
  @tf.custom_gradient
  def _lr_mult(x):
    def grad(dy):
      return dy * alpha * tf.ones_like(x)
    return x, grad
  return _lr_mult

x0 = tf.Variable(1.)
x1 = tf.Variable(1.)
loss = tf.square(x0) + tf.square(lr_mult(0.1)(x1))

step = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(loss)

sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
tf.local_variables_initializer().run()

for _ in range(5):
  sess.run([step])
  print(sess.run([x0, x1, loss]))

【讨论】：

其实custom_gradient从TF 1.7开始就可以使用了

很棒的帖子，但我认为看到上述代码的输出非常有用：[1][0.8, 0.98, 1.6004001][2][2][0.64, 0.96040004, 1.3319682][3][0.51199996, 0.94119203, 1.1479864][4][0.40959996, 0.92236817, 1.0185351]@ 987654332@[0.32767996, 0.9039208, 0.924447]

【参考方案3】：

1 月 22 日更新：下面的配方仅适用于 GradientDescentOptimizer，其他保持运行平均值的优化器将在参数更新之前应用学习率，因此下面的配方不会影响等式的一部分

除了Rafal的方法，你还可以使用Optimizer的compute_gradients、apply_gradients接口。例如，这是一个玩具网络，我使用 2 倍的学习率作为第二个参数

x = tf.Variable(tf.ones([]))
y = tf.Variable(tf.zeros([]))
loss = tf.square(x-y)
global_step = tf.Variable(0, name="global_step", trainable=False)

opt = tf.GradientDescentOptimizer(learning_rate=0.1)
grads_and_vars = opt.compute_gradients(loss, [x, y])
ygrad, _ = grads_and_vars[1]
train_op = opt.apply_gradients([grads_and_vars[0], (ygrad*2, y)], global_step=global_step)

init_op = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init_op)
for i in range(5):
  sess.run([train_op, loss, global_step])
  print sess.run([x, y])

你应该看到

[0.80000001, 0.40000001]
[0.72000003, 0.56]
[0.68800002, 0.62400001]
[0.67520005, 0.64960003]
[0.67008007, 0.65984005]

【讨论】：

这在使用 SGD 时很好，但不确定它是否最适合计算过去梯度值的统计数据的更花哨的优化器......只要你不想在训练期间更改学习率。

@YaroslavBulatov 这也适用于 MomentumOptimizer 吗？在这种情况下，compute_gradients 和 apply_gradients 函数究竟做了什么？

【参考方案4】：

为每个变量收集学习率乘数，例如：

self.lr_multipliers[var.op.name] = lr_mult

然后在应用渐变之前应用它们：

def _train_op(self):
  tf.scalar_summary('learning_rate', self._lr_placeholder)
  opt = tf.train.GradientDescentOptimizer(self._lr_placeholder)
  grads_and_vars = opt.compute_gradients(self._loss)
  grads_and_vars_mult = []
  for grad, var in grads_and_vars:
    grad *= self._network.lr_multipliers[var.op.name]
    grads_and_vars_mult.append((grad, var))
    tf.histogram_summary('variables/' + var.op.name, var)
    tf.histogram_summary('gradients/' + var.op.name, grad)
  return opt.apply_gradients(grads_and_vars_mult)

你可以找到整个例子here。

【参考方案5】：

Sergey Demyanov 答案的细微变化，您只需指定要更改的学习率

from collections import defaultdict

self.learning_rates = defaultdict(lambda: 1.0)
...
x = tf.layers.Dense(3)(x)
self.learning_rates[x.op.name] = 2.0
...
optimizer = tf.train.MomentumOptimizer(learning_rate=1e-3, momentum=0.9)
grads_and_vars = optimizer.compute_gradients(loss)
grads_and_vars_mult = []
for grad, var in grads_and_vars:
    grad *= self.learning_rates[var.op.name]
    grads_and_vars_mult.append((grad, var))
train_op = optimizer.apply_gradients(grads_and_vars_mult, tf.train.get_global_step())

【参考方案6】：

前 5 层的学习率为 0.00001，最后一层的学习率为 0.001。知道如何实现这一目标吗？

使用 tf.stop_gradient 有一个简单的方法可以做到这一点。 这是一个 3 层的示例：

x = layer1(input)
x = layer2(x)
output = layer3(x)

您可以将前两层的渐变缩小 1/100：

x = layer1(input)
x = layer2(x)
x = 1/100*x + (1-1/100)*tf.stop_gradient(x)
output = layer3(x)

在 layer2 上，“流”分为两个分支：一个贡献为 1/100 的分支定期计算其梯度，但梯度幅度缩小了 1/100 的比例，另一个分支提供剩余的由于 tf.stop_gradient 运算符，“流动”不会对梯度产生影响。因此，如果您在模型优化器上使用 0.001 的学习率，前两层的学习率实际上将是 0.00001。

【讨论】：

这也会影响上游变量的梯度。 IE 如果您希望layer1 具有与layer2 不同的LR，您必须确保根据您缩放layer2 渐变的方式缩放layer1 渐变。我可以看到这种级联效应变得很难跟踪，尤其是对于更深的网络。

【参考方案7】：

如果你碰巧在使用 tf.slim + slim.learning.create_train_op，这里有一个很好的例子： https://github.com/google-research/tf-slim/blob/master/tf_slim/learning.py#L65

# Create the train_op and scale the gradients by providing a map from variable
  # name (or variable) to a scaling coefficient:
  gradient_multipliers = 
    'conv0/weights': 1.2,
    'fc8/weights': 3.4,
  
  train_op = slim.learning.create_train_op(
      total_loss,
      optimizer,
      gradient_multipliers=gradient_multipliers)

不幸的是，如果您想逐渐修改乘数，似乎无法使用 tf.Variable 代替浮点值。