python - Cómo crear un optimizador en Tensorflow

python-2.7 optimization

Question

Quiero escribir un nuevo algoritmo de optimización para mi red en Tensorflow. Espero implementar el algoritmo de optimización de Levenberg Marquardt , que ahora está excluido de la API de TF. Encontré poca documentación sobre cómo escribir un optimizador personalizado, así que le pregunto si alguien me puede dar algún consejo. Gracias.

Answer 1

Antes de ejecutar la sesión de Tensorflow, uno debe iniciar un optimizador como se ve a continuación:

# Gradient Descent
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

tf.train.GradientDescentOptimizer es un objeto de la clase GradientDescentOptimizer y, como su nombre lo indica, implementa el algoritmo de descenso de gradiente.

El método minimizar () se llama con un "costo" como parámetro y consiste en los dos métodos compute_gradients () y luego apply_gradients () .

Para la mayoría de las implementaciones de optimizador (personalizadas), el método apply_gradients () debe adaptarse.

Este método se basa en el (nuevo) Optimizer (clase), que crearemos, para implementar los siguientes métodos: _create_slots (), _prepare (), _apply_dense () y _apply_sparse () .

• _create_slots () y _prepare () crean e inicializan variables adicionales, como el impulso.

• _apply_dense () y _apply_sparse () implementan las operaciones reales, que actualizan las variables.

Las operaciones generalmente se escriben en C ++. Sin tener que cambiar el encabezado de C ++ usted mismo, todavía puede devolver un envoltorio de Python de algunos Ops a través de estos métodos. Esto se hace de la siguiente manera:

def _create_slots(self, var_list):
   # Create slots for allocation and later management of additional 
   # variables associated with the variables to train.
   # for example: the first and second moments.
   ''''''
   for v in var_list:
      self._zeros_slot(v, "m", self._name)
      self._zeros_slot(v, "v", self._name)
   ''''''
def _apply_dense(self, grad, var):
   #define your favourite variable update
    # for example:
   ''''''
   # Here we apply gradient descents by substracting the variables 
   # with the gradient times the learning_rate (defined in __init__)
   var_update = state_ops.assign_sub(var, self.learning_rate * grad) 
   ''''''
   #The trick is now to pass the Ops in the control_flow_ops and 
   # eventually groups any particular computation of the slots your 
   # wish to keep track of:
   # for example:    
   ''''''
    m_t = ...m... #do something with m and grad
    v_t = ...v... # do something with v and grad
    ''''''
  return control_flow_ops.group(*[var_update, m_t, v_t])

Para obtener una explicación más detallada con un ejemplo, vea esta publicación del blog https://www.bigdatarepublic.nl/custom-optimizer-in-tensorflow/

Answer 2

El ejemplo más simple de un optimizador es probablemente el optimizador de pendiente de gradiente . Muestra cómo se crea una instancia de la clase de optimizador básico. La documentación de la clase base del optimizador explica lo que hacen los métodos.

El lado de Python de los optimizadores agrega nuevos nodos al gráfico que calcula y aplica los gradientes que se propagan hacia atrás. Proporciona los parámetros que se pasan a las operaciones y realiza parte de la administración de alto nivel del optimizador. Entonces, necesitas la opción real "Aplicar".

Las operaciones tienen un componente de Python y C ++. Escribir una operación de entrenamiento es el mismo (pero especializado) que el proceso general de agregar una Op a TensorFlow .

Para ver un conjunto de ejemplos de operaciones de entrenamiento que computan y aplican gradientes, vea python/training/training_ops.py - este es el pegamento de Python para las operaciones de entrenamiento reales. Tenga en cuenta que el código aquí es principalmente acerca de la inferencia de formas: el cálculo se realizará en C ++.

La matemática real para aplicar los gradientes es manejada por una operación (recordando que, en general, las operaciones están escritas en C ++). En este caso, las opciones de aplicar gradientes se definen en core/kernels/training_ops.cc . Puede ver, por ejemplo, la implementación de ApplyGradientDescentOp allí, que hace referencia a un functor ApplyGradientDescent:

var.device(d) -= grad * lr();

La implementación de la Op. En sí sigue a la implementación de cualquier otra operación como se describe en los documentos de agregar y operar.