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

我想知道是否有一种方法，我可以使用不同的学习速度为不同的层次，如什么是在咖啡馆。我试图修改一个预先训练过的模型，并将其用于其他任务。我想要的是加快新添加层的训练，并保持训练层的低学习率，以防止它们被扭曲。例如，我有一个5层的预训练模型。现在我添加一个新的conv层并对其进行微调。前5层的学习率为0.00001，最后一层的学习率为0.001。您知道如何实现这一点吗？

使用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并将相应的渐变传递给两个优化器来缓解

相关问题：

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

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（.）

在优化器中被调用两次。这可能会导致执行一些冗余操作（例如，第一层上的渐变可以对以下层的渐变重复使用一些计算）。

更新1月22日：下面的配方仅适用于

GradientDescentOptimizer

，其他保持运行平均值的优化器将在参数更新之前应用学习率，因此下面的配方不会影响方程的这一部分

除了Rafal的方法外，您还可以使用

优化器

的

计算梯度

，

应用梯度

接口。例如，这里有一个玩具网络，我使用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]

---

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

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)

你可以找到整个例子

前5层的学习率为0.00001，最后一层的学习率为0.001。你知道如何做到这一点吗

使用tf.stop\u梯度有一种简单的方法。 下面是一个具有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)

---

在第2层，“流”分为两个分支：一个分支的贡献为1/100，它定期计算其梯度，但梯度大小按1/100的比例缩小，另一个分支提供剩余的“流”，但由于tf.stop_梯度操作符，它不贡献梯度。因此，如果在模型优化器上使用0.001的学习率，前两层的学习率实际上将为0.00001。

Tensorflow 1.7引入了

tf。自定义梯度

大大简化了学习率乘数的设置，现在与任何优化器兼容，包括那些累积梯度统计。比如说,

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

---

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

---

如果您碰巧使用tf.slim+slim.learning.create\u train\u op，这里有一个很好的例子：

---

不幸的是，如果您想逐渐修改乘数，似乎不可能使用tf.变量而不是浮点值。

这在使用SGD时很好，但不确定它是否适用于计算过去梯度值统计信息的更奇特的优化器。。。只要你不想在训练期间改变学习速度，这可能不会有什么不同。@YaroslavBulatov MomentumOptimizer也可以这样做吗？在这种情况下，计算梯度和应用梯度函数到底做了什么？谢谢你的回答Rafal。我仍然有点想知道当你说它在速度方面的缺点时，它会对性能产生多大的影响。如果我正在训练一个庞大的网络，如果这是一个巨大的负担，那将不是一个好的选择。另外，你能更具体地谈谈你的第二种方法吗？如何显式调用tf.gradients（）？对不起，我还是个新手。thx人，第二行应该是“train_op2=opt2.apply_gradients（.）”吗？如果我理解正确的话。在您的第一个示例中，您在

最小化中使用了
loss
，因此我认为您的第二个示例应该使用
tf.梯度（loss，var_list1+var_list2）
有任何原因不能扩展到3个或更多单独的列表吗？如果我在
应用梯度中使用
全局步骤
，您会在
opt1
和
opt2
中使用它吗？还是只在最后一个
应用梯度
中使用它？TF 1.8的
TF。自定义梯度
现在大大简化了这个问题——请看下面我的答案。事实上，TF1.7great post提供了自定义梯度，但我认为看到上面代码的输出非常有用：
[1]
[0.8,0.98,1.6004001]
[2]
[0.64,0.96040004,1.3319682]
[3]
[0.51199996,0.94119203,1.1479864]
[4]
[0.40959996,0.92236817,1.0185351]
[0.32767996,0.9039208,0.924447]
这也会影响上游变量的梯度。也就是说，如果您希望
layer1
具有与
layer2
不同的LR，则必须确保根据缩放
layer2
渐变的方式缩放
layer1
渐变。我可以看到这种级联效应越来越难以跟踪，尤其是对于更深层次的网络。
# 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)