Ottenere il tasso di apprendimento corrente da un tf.train.AdamOptimizer

Question

Vorrei stampare il tasso di apprendimento per ogni fase di formazione del mio nn.

So che Adam ha un tasso di apprendimento adattivo, ma c'è un modo che posso vedere questo (per la visualizzazione in tensorboard)

Answer 1

Sung Kim suggerimento lavorato per me, i miei passi esatte sono state:

lr = 0.1 
step_rate = 1000 
decay = 0.95 

global_step = tf.Variable(0, trainable=False) 
increment_global_step = tf.assign(global_step, global_step + 1) 
learning_rate = tf.train.exponential_decay(lr, global_step, step_rate, decay, staircase=True) 

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, epsilon=0.01) 
trainer = optimizer.minimize(loss_function) 

# Some code here 

print('Learning rate: %f' % (sess.run(trainer ._lr))) 

Answer 2

Tutti gli ottimizzatori dispongono di una variabile privata che contiene il valore di un tasso di apprendimento.

In adagrad e gradient descent si chiama self._learning_rate. In adam è self._lr.

Quindi sarà necessario stampare sess.run(optimzer._lr) per ottenere questo valore. Sess.run è necessario perché sono tensori.

Answer 3

Penso che la cosa più semplice che puoi fare sia la sottoclasse dell'ottimizzatore.

Ha diversi metodi, che immagino vengano spediti in base al tipo di variabile. Le variabili Dense regolari sembrano passare attraverso lo _apply_dense. Questa soluzione non funzionerà per sparse o altre cose.

Se si guarda il implementation si può vedere che sta memorizzando gli EMA m e t in questi "slot". Quindi, qualcosa di simile sembra farlo:

class MyAdam(tf.train.AdamOptimizer): 
    def _apply_dense(self, grad, var): 
     m = self.get_slot(var, "m") 
     v = self.get_slot(var, "v") 

     m_hat = m/(1-self._beta1_power) 
     v_hat = v/(1-self._beta2_power) 

     step = m_hat/(v_hat**0.5 + self._epsilon_t) 

     # Use a histogram summary to monitor it during training. 
     tf.summary.histogram("hist", step) 

     return super(MyAdam,self)._apply_dense(grad, var) 

step qui sarà nell'intervallo [-1,1], questo è ciò che viene moltiplicato per il tasso di apprendimento, alla determina il passaggio effettivo applicato ai parametri.

Spesso non c'è alcun nodo nel grafico perché c'è un grande training_ops.apply_adam che fa tutto.

Qui sto solo creando un sommario dell'istogramma da esso. Ma potresti incollarlo in un dizionario allegato all'oggetto e leggerlo più tardi o fare quello che vuoi con esso.

Droping che in mnist_deep.py, e l'aggiunta di alcuni riepiloghi per il ciclo di formazione:

all_summaries = tf.summary.merge_all() 
file_writer = tf.summary.FileWriter("/tmp/Adam") 
with tf.Session() as sess: 
    sess.run(tf.global_variables_initializer()) 
    for i in range(20000): 
     batch = mnist.train.next_batch(50) 
     if i % 100 == 0: 
      train_accuracy,summaries = sess.run(
       [accuracy,all_summaries], 
       feed_dict={x: batch[0], y_: batch[1], 
          keep_prob: 1.0}) 
      file_writer.add_summary(summaries, i) 
      print('step %d, training accuracy %g' % (i, train_accuracy)) 
     train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5}) 

produce il seguente figura TensorBoard: