¿Cómo establecer la tasa de aprendizaje en capas en Tensorflow?

Actualización Jan 22 : receta a continuación es solo una buena idea para GradientDescentOptimizer, otros optimizadores que mantienen un promedio de ejecución aplicarán la tasa de aprendizaje antes de la actualización del parámetro, por lo que receta a continuación no afectará esa parte de la ecuación

Además del enfoque de Rafal, podrías usar compute_gradients, apply_gradients interfaz de Optimizer. Por ejemplo, aquí hay una red de juguetes donde uso 2 veces la tasa de aprendizaje para el segundo parámetro

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

Deberías ver

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

Tensorflow 1.7 introdujo tf.custom_gradient que simplifica enormemente la configuración de multiplicadores de velocidad de aprendizaje, de una manera que ahora es compatible con cualquier optimizador, incluidos los que acumulan estadísticas de gradiente. Por ejemplo,

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

Recopilar multiplicadores de tasa de aprendizaje para cada variable como:

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

Y luego aplicarlos durante antes de aplicar los gradientes como:

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)

Puedes encontrar el ejemplo completo aquí.

Las primeras 5 capas tendrían una tasa de aprendizaje de 0.00001 y la última tendría 0.001. ¿Alguna idea de cómo lograrlo?

Hay una manera fácil de hacerlo usando tf.stop_gradient. Aquí hay un ejemplo con 3 capas:

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

Puede reducir su gradiente en las dos primeras capas en una proporción de 1/100:

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

En la capa 2, el "flujo" se divide en dos ramas: una que tiene una contribución de 1/100 calcula su gradiente regularmente pero con un gradiente la magnitud reducida en una proporción de 1/100, la otra rama proporciona el "flujo" restante sin contribuir al gradiente debido al tf.stop_gradient operador. Como resultado, si utiliza una tasa de aprendizaje de 0.001 en su optimizador de modelos, las dos primeras capas tendrán virtualmente una tasa de aprendizaje de 0.00001.