L'obtention de l'apprentissage en cours taux de tf.le train.AdamOptimizer

Je voudrais imprimer le taux d'apprentissage pour chaque étape de mon nn.

Je sais qu'Adam a un apprentissage adaptatif taux, mais est-il une manière que je peux voir ceci (pour la visualisation dans tensorboard)

  • Par rapidement la lecture du code, vous pouvez obtenir de tr: imprimer sess.exécuter(adam_op._lr_t), après avoir adam_op = tf.le train.AdamOptimizer(0.1, beta1=0.5, beta2=0.5) , train_op = adam_op.minimiser(coût). Cependant, il n'est pas sûr de son travail dans votre code. Pouvez-vous qickly test?
  • Note de côté: La bonne façon de penser à propos d'adam n'est pas que l'apprentissage de taux (mise à l'échelle de la dégradés), mais comme une étape de taille. Le learning_rate que vous transmettez est la taille maximale du pas (par paramètre), Adam prend des mesures jusqu'à la taille, selon le degré de cohérence de la pente est.
  • OK @mdaoust, mais alors comment puis-je obtenir le taux d'apprentissage à chaque étape? J'ai essayé Sung Kim suggestion, mais ne fonctionne pas, car il renvoie une ligne plate. Merci.
InformationsquelleAutor kmace | 2016-05-02
  1. 15

    Tous les optimiseurs disposent d'une salle de variable qui contient la valeur de l'apprentissage d'un taux de.

    Dans adagrad et la descente de gradient il est appelé self._learning_rate. Dans adam il est self._lr.

    De sorte que vous aurez juste besoin d'imprimer sess.run(optimzer._lr) d'obtenir cette valeur. Sess.run est nécessaire, car ils sont des tenseurs.

    InformationsquelleAutor Salvador Dali
  2. 9

    Sung Kim suggestion a fonctionné pour moi, mon étapes exactes ont été:

    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)))
    • J'utilise GradientDescentOptimizer et l'utilisation self._learning_rate. Il ne fonctionne pas pour moi. J'obtiens l'erreur AttributeError: 'Operation' object has no attribute '_learning_rate'
    InformationsquelleAutor X. Serra
  3. 2

    Je pense que la meilleure chose que vous pouvez faire est sous-classe de l'optimiseur.

    Il y a plusieurs méthodes, qui, je pense, d'obtenir expédiés en fonction de type de variable. Régulière Dense variables semblent passer par _apply_dense. Cette solution ne fonctionne pas pour clairsemée ou d'autres choses.

    Si vous regardez la la mise en œuvre vous pouvez voir que c'est le stockage de l' m et t EMAs dans ces "machines à sous". Donc quelque chose comme cela semble le faire:

    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 ici sera dans l'intervalle [-1,1], c'est ce qui est multiplié par le taux d'apprentissage, détermine à l'étape appliquée aux paramètres.

    Il n'y a souvent pas de nœud dans le graphe pour elle car il y a un gros training_ops.apply_adam qui fait tout.

    Ici, je suis juste la création d'un histogramme de synthèse à partir d'elle. Mais vous pouvez le coller dans un dictionnaire attaché à l'objet et à le lire plus tard ou faire ce que vous voulez avec elle.

    Dropant que dans mnist_deep.py, et en ajoutant quelques résumés à la formation de la boucle:

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

    Produit le texte suivant figure dans TensorBoard:

    L'obtention de l'apprentissage en cours taux de tf.le train.AdamOptimizer

    • En raison de contraintes de ressources, j'ai explicitement en place mon réseau sur différents Processeurs, et ce sous-classement hack me donne une erreur: Could not satisfy explicit device specification '/device:GPU:1' because no supported kernel for GPU devices is available. Retrait de la tf.summary.histogram ligne de retirer la plainte.
    InformationsquelleAutor mdaoust
  4. 2

    Dans TensorFlow sources de courant lr pour Adam optimiseur calcule comme: 

        lr = (lr_t * math_ops.sqrt(1 - beta2_power) /(1 - beta1_power))

    Donc, essayez-le:

        current_lr = (optimizer._lr_t * tf.sqrt(1 - 
    optimizer._beta2_power) /(1 - optimizer._beta1_power))

    eval_current_lr = sess.run(current_lr)
    • dans le code de votre beta2_power et beta1_power semble être changé , par rapport à la tf sources que vous avez écrit ci-dessus
    • Vous avez raison, merci.
    InformationsquelleAutor Vladislav Dusyak