Comment définir le taux d'apprentissage adaptatif pour GradientDescentOptimizer?

J'utilise TensorFlow pour former un réseau neuronal. Voici comment j'initialise le GradientDescentOptimizer:

init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)

mse        = tf.reduce_mean(tf.square(out - out_))
train_step = tf.train.GradientDescentOptimizer(0.3).minimize(mse)

Le problème ici est que je ne sais pas comment définir une règle de mise à jour pour le taux d'apprentissage ou une valeur de décroissance pour cela.

Comment puis-je utiliser un taux d'apprentissage adaptatif ici?

Tout d'abord, tf.train.GradientDescentOptimizerest conçu pour utiliser un taux d'apprentissage constant pour toutes les variables dans toutes les étapes. TensorFlow fournit également des optimiseurs adaptatifs prêts à l'emploi, y compris le tf.train.AdagradOptimizeret le tf.train.AdamOptimizer, et ceux-ci peuvent être utilisés comme remplacements instantanés.

Cependant, si vous souhaitez contrôler le taux d'apprentissage avec une descente de gradient autrement vanille, vous pouvez profiter du fait que l' learning_rateargument du tf.train.GradientDescentOptimizerconstructeur peut être un Tensorobjet. Cela vous permet de calculer une valeur différente pour le taux d'apprentissage à chaque étape, par exemple:

learning_rate = tf.placeholder(tf.float32, shape=[])
# ...
train_step = tf.train.GradientDescentOptimizer(
    learning_rate=learning_rate).minimize(mse)

sess = tf.Session()

# Feed different values for learning rate to each training step.
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.1})
sess.run(train_step, feed_dict={learning_rate: 0.01})
sess.run(train_step, feed_dict={learning_rate: 0.01})

Vous pouvez également créer un scalaire tf.Variablecontenant le taux d'apprentissage et l'attribuer à chaque fois que vous souhaitez modifier le taux d'apprentissage.

Tensorflow fournit une op pour appliquer automatiquement une décroissance exponentielle à un tenseur de taux d'apprentissage: tf.train.exponential_decay. Pour un exemple d'utilisation, voir cette ligne dans l'exemple de modèle convolutif MNIST . Ensuite, utilisez la suggestion de @ mrry ci-dessus pour fournir cette variable comme paramètre learning_rate à l'optimiseur de votre choix.

L'extrait clé à regarder est:

# Optimizer: set up a variable that's incremented once per batch and
# controls the learning rate decay.
batch = tf.Variable(0)

learning_rate = tf.train.exponential_decay(
  0.01,                # Base learning rate.
  batch * BATCH_SIZE,  # Current index into the dataset.
  train_size,          # Decay step.
  0.95,                # Decay rate.
  staircase=True)
# Use simple momentum for the optimization.
optimizer = tf.train.MomentumOptimizer(learning_rate,
                                     0.9).minimize(loss,
                                                   global_step=batch)

Notez le global_step=batchparamètre à minimiser. Cela indique à l'optimiseur d'incrémenter utilement le paramètre 'batch' pour vous chaque fois qu'il s'entraîne.

L'algorithme de descente de gradient utilise le taux d'apprentissage constant que vous pouvez fournir lors de l'initialisation . Vous pouvez passer différents taux d'apprentissage de la manière indiquée par Mrry.

Mais au lieu de cela, vous pouvez également utiliser des optimiseurs plus avancés qui ont un taux de convergence plus rapide et s'adaptent à la situation.

Voici une brève explication basée sur ma compréhension:

• l'élan aide SGD à naviguer dans les directions pertinentes et adoucit les oscillations dans le non pertinent. Il ajoute simplement une fraction de la direction de l'étape précédente à une étape actuelle. Cela permet une amplification de la vitesse dans la bonne direction et adoucit l'oscillation dans les mauvaises directions. Cette fraction se situe généralement dans la plage (0, 1). Il est également logique d'utiliser l'élan adaptatif. Au début de l'apprentissage, un grand élan ne fera qu'entraver votre progression, il est donc logique d'utiliser quelque chose comme 0,01 et une fois que tous les gradients élevés ont disparu, vous pouvez utiliser un élan plus grand. Il y a un problème avec l'élan: lorsque nous sommes très proches de l'objectif, notre élan dans la plupart des cas est très élevé et il ne sait pas qu'il devrait ralentir. Cela peut le faire rater ou osciller autour des minima
• Le gradient accéléré nesterov surmonte ce problème en commençant à ralentir tôt. Dans l'élan, nous calculons d'abord le gradient, puis faisons un saut dans cette direction amplifié par l'élan que nous avions précédemment. NAG fait la même chose mais dans un autre ordre: dans un premier temps, nous faisons un grand saut en fonction de nos informations stockées, puis nous calculons le gradient et effectuons une petite correction. Ce changement apparemment hors de propos donne des accélérations pratiques significatives.
• AdaGrad ou gradient adaptatif permet au taux d'apprentissage de s'adapter en fonction des paramètres. Il effectue des mises à jour plus importantes pour les paramètres peu fréquents et des mises à jour plus petites pour les paramètres fréquents. Pour cette raison, il convient parfaitement aux données rares (PNL ou reconnaissance d'image). Un autre avantage est qu'il élimine fondamentalement la nécessité d'ajuster le taux d'apprentissage. Chaque paramètre a son propre taux d'apprentissage et en raison des particularités de l'algorithme, le taux d'apprentissage diminue de manière monotone. Cela pose le plus gros problème: à un moment donné, le taux d'apprentissage est si faible que le système cesse d'apprendre
• AdaDelta résout le problème de la diminution monotone du taux d'apprentissage dans AdaGrad. Dans AdaGrad, le taux d'apprentissage a été calculé approximativement comme un divisé par la somme des racines carrées. À chaque étape, vous ajoutez une autre racine carrée à la somme, ce qui entraîne une diminution constante du dénominateur. Dans AdaDelta, au lieu de sommer toutes les racines carrées passées, il utilise une fenêtre glissante qui permet à la somme de diminuer. RMSprop est très similaire à AdaDelta

• Adam ou élan adaptatif est un algorithme similaire à AdaDelta. Mais en plus de stocker les taux d'apprentissage pour chacun des paramètres, il stocke également les changements d'élan pour chacun d'eux séparément

  A quelques visualisations :

À partir de la documentation officielle de tensorflow

global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,
                                       100000, 0.96, staircase=True)

# Passing global_step to minimize() will increment it at each step.
learning_step = (
tf.train.GradientDescentOptimizer(learning_rate)
.minimize(...my loss..., global_step=global_step))

Si vous souhaitez définir des taux d'apprentissage spécifiques pour des intervalles d'époques comme 0 < a < b < c < .... Ensuite, vous pouvez définir votre taux d'apprentissage comme un tenseur conditionnel, conditionnel à l'étape globale, et le fournir normalement à l'optimiseur.

Vous pouvez y parvenir avec un tas d' tf.condinstructions imbriquées , mais il est plus facile de construire le tenseur de manière récursive:

def make_learning_rate_tensor(reduction_steps, learning_rates, global_step):
    assert len(reduction_steps) + 1 == len(learning_rates)
    if len(reduction_steps) == 1:
        return tf.cond(
            global_step < reduction_steps[0],
            lambda: learning_rates[0],
            lambda: learning_rates[1]
        )
    else:
        return tf.cond(
            global_step < reduction_steps[0],
            lambda: learning_rates[0],
            lambda: make_learning_rate_tensor(
                reduction_steps[1:],
                learning_rates[1:],
                global_step,)
            )

Ensuite, pour l'utiliser, vous devez savoir combien d'étapes d'entraînement il y a dans une seule époque, afin que nous puissions utiliser l'étape globale pour basculer au bon moment, et enfin définir les époques et les taux d'apprentissage que vous souhaitez. Donc, si je veux les taux d'apprentissage [0.1, 0.01, 0.001, 0.0001]pendant les intervalles d'époque de [0, 19], [20, 59], [60, 99], [100, \infty]respectivement, je ferais:

global_step = tf.train.get_or_create_global_step()
learning_rates = [0.1, 0.01, 0.001, 0.0001]
steps_per_epoch = 225
epochs_to_switch_at = [20, 60, 100]
epochs_to_switch_at = [x*steps_per_epoch for x in epochs_to_switch_at ]
learning_rate = make_learning_rate_tensor(epochs_to_switch_at , learning_rates, global_step)