La Descente de Gradient vs Adagrad vs Élan dans TensorFlow

Je suis étudiant en TensorFlow et comment l'utiliser, même si je ne suis pas un expert des réseaux de neurones et apprentissage en profondeur (juste les bases).

Didacticiels, je ne comprends pas le réel et la pratique, les différences entre les trois optimiseurs de la perte. Je regarde le API et je comprends les principes, mais mes questions sont:

1. Quand est-il préférable d'utiliser à la place des autres ?

2. Il existe des différences marquées savoir ?

Il n'y a pas de théorie qui optimizer est censé mieux travailler sur, disons, MNIST, afin que les gens essayer plusieurs et choisir celui qui convient le mieux à leur problème. La Descente de Gradient est généralement le pire de tous, le Momentum/AdaGrad peut être meilleur ou pire que l'autre selon le dataset
Ok, j'ai besoin de créer un modèle pour la reconnaissance d'images avec 4 - 5 classes de reconnaissance. Si j'utilise le Imagenet dataset est-ce que vous me suggérer ?
AdamOptimizer semble bien fonctionner sur Imagenet
Juste à ajouter sur ce qui a déjà été dit, le nombre d'hyper paramètres requis par l'optimiseur doit également être gardé à l'esprit lors du choix d'un optimiseur. La Descente de Gradient est lent, mais vous ne devez définir au taux d'apprentissage.

InformationsquelleAutor Kyrol | 2016-03-22

deep-learning tensorflow

169

Voici une brève explication basée sur ma compréhension:
- élan aide SGD pour naviguer le long de la pertinente les directions et adoucit les oscillations dans la pertinence. 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 le bon sens et adoucit oscillation dans de fausses directions. Cette fraction est généralement dans l'ensemble (0, 1) de la gamme. Il est également judicieux d'adaptation dynamique. Dans le début de l'apprentissage d'un grand élan ne fait qu'entraver votre progression, il est donc logique d'utiliser quelque chose comme 0,01 et une fois tous les hauts gradients disparu, vous pouvez utiliser un plus grand dynamisme. Il y a un problème avec élan: quand on est très près du but, notre élan dans la plupart des cas, est très élevé et il ne sait pas qu'il doit ralentir. Cela peut l'amener à manquer ou osciller autour de l'minima
- nesterov a accéléré gradient permet de surmonter ce problème a commencé à ralentir au début. Dans l'élan, nous avons d'abord calculer le gradient et puis faire un saut dans cette direction amplifié par tout l'élan que nous avions auparavant. NAG fait la même chose mais dans un autre ordre: dans un premier temps nous faire un grand saut basé sur nos informations stockées, puis nous calculons le gradient et de faire une petite correction. Ce qui semble hors de propos de changement de donne en réalité beaucoup plus rapides.
- AdaGrad ou adaptative gradient permet l'apprentissage des taux d'adapter en fonction de paramètres. Il effectue plus de mises à jour pour les rares paramètres et de petites mises à jour fréquentes pour un. De ce fait, il est bien adapté pour le peu de données (PNL ou la reconnaissance d'image). Un autre avantage est que, essentiellement, il élimine la nécessité de régler le taux d'apprentissage. Chaque paramètre dispose de son propre apprentissage et de taux en raison des particularités de l'algorithme, le taux d'apprentissage est monotone décroissante. Cela provoque le plus gros problème: à un certain point dans le temps, le taux d'apprentissage est si petite que le système cesse d'apprentissage.
- AdaDelta résout le problème de façon monotone décroissant d'apprentissage taux d'AdaGrad. Dans AdaGrad l'apprentissage des taux a été calculé approximativement comme l'un divisé par la somme des racines carrées. À chaque étape, vous ajoutez un autre racine carrée de la somme, ce qui provoque dénominateur ne cessent d'augmenter. Dans AdaDelta au lieu d'additionner toutes les dernières racines carrées, il utilise fenêtre coulissante qui permet à la somme de diminuer. RMSprop est très similaire à AdaDelta
- Adam ou adaptatif dynamique est un algorithme similaire à AdaDelta. Mais outre le stockage de l'apprentissage pour chacun des paramètres, il stocke également le momentum change pour chacun d'eux séparément.
  
  Un quelques visualisations:
Je dirais que SGD, l'Impulsion et la Nesterov sont inférieures à la dernière 3.
- "SGD, l'Impulsion et la Nesterov sont inférieures à la dernière 3", ils ne sont pas inférieur, ils sont plus lent. Il ya une raison pourquoi les gens utilisent SGD+Élan pour la formation dans les documents. SGD+Élan, ont plus de chances de parvenir à plat minima.
- si nous voulons être pédant, puis on ne peut pas utiliser le mot plus lent aussi. Car en théorie, il est toujours possible de trouver une surface et un point de départ de l'algorithme réalise le meilleur. Mais dans la pratique ce n'est pas très utile.
- À partir des commentaires dans le lien que vous avez fourni sur AdaDelta: "il n'existe pas de conclusion claire de l'algorithme à choisir et à quel moment. Tous d'entre eux fonctionnent différemment selon la nature du problème et de la paramétrisation. [...] Un ‘solide’ conclusion qui peut être tirée est ici “pour choisir ce qui fonctionne le mieux pour votre problème” – j'ai peur"
- Ce document (arxiv.org/abs/1705.08292) explique comment SGD arrive souvent à de meilleures solutions que les méthodes adaptatives. Mieux, dans le sens d'une meilleure validation/perte de précision (c'est à dire le modèle généralise mieux) plutôt que d'une formation rapide fois
- Qu'entendez-vous par "Adam ou adaptatif dynamique"? comme cette réponse explique, Adam est l'abréviation de "adaptive moment d'estimation", selon l'Adam originel de papier.
- "Dans AdaGrad l'apprentissage des taux a été calculé approximativement comme l'un divisé par la somme des racines carrées." Je ne vois pas comment c'est le rapprochement que AdaGrad fait. Ce qui me manque? (Dans ma réponse vous pouvez trouver le calcul que AdaGrad effectue, comme je le comprends)
- J'ai hate de jouer au modérateur, mais les minéraux de la réponse est plus de fond et de contentful (utile) pour les futurs utilisateurs. Merci de laisser un upvote et de se déplacer sur
- Je suis actuellement l'intention d'écrire une longue réponse, mais dans ce cas je ne suis pas pour demain/le jour d'après, voici une liste de ressources, je suis la recherche utile de comprendre les optimiseurs: 1. keras comment utilisation ces optimiseurs, et une liste complète d'entre eux), 2. SGD, l'Élan, AdaGrad, AdaDelta, et AdaM, 3. Papier discuter des optimiseurs de Geoffrey Hinton et coll.
InformationsquelleAutor Salvador Dali
10

Salvador Dali répondre déjà explique sur les différences entre certaines méthodes populaires (c'est à dire les optimiseurs), mais je voudrais essayer d'élaborer sur eux un peu plus.

(Notez que nos réponses sont en désaccord sur certains points, notamment concernant ADAGRAD.)

Classique de la quantité de mouvement (CM) vs Nesterov Accéléré de Gradient (NAG)

(Basée principalement sur l'article 2 dans le papier Sur l'importance de l'initialisation et de la dynamique dans l'apprentissage en profondeur.)

Chaque étape de la CM et de NAG est en fait composé de deux sous-étapes:
- Une dynamique sous-étape - C'est tout simplement une fraction (typiquement dans la gamme [0.9,1)) de la dernière étape.
- Un gradient dépendant de la sous-étape - C'est comme l'étape habituelle dans SGD - il est le produit de l'apprentissage de taux et le vecteur opposé de la pente, tandis que le gradient est calculé où cette sous-étape commence à partir.
CM prend le gradient de la sous-étape première, tandis que NAG prend de l'élan de la sous-étape première.

Voici une démonstration de une réponse à propos de l'intuition pour la CM et de NAG:

Donc NAG semble être le meilleur (au moins dans l'image), mais pourquoi?

La chose importante à noter est qu'il n'a pas d'importance lorsque la dynamique sous-étape vient - il serait le même de toute façon. Par conséquent, on peut très bien se comporter est si la dynamique sous-étape a déjà été prises.

Ainsi, la question est en fait: en Supposant que le gradient de la sous-mesure est prise après l'élan de la sous-étape, doit-on calculer le gradient de la sous-étape que s'il a commencé dans la position avant ou après la prise de la dynamique sous-étape?

"Après" qui semble être la bonne réponse, comme souvent, le dégradé à un certain point θ à peu près les points de vous diriger dans la direction de θ à un minimum (avec la relativement droit d'ampleur), tandis que la pente à un autre point est moins susceptible de vous diriger dans la direction de θ à un minimum (avec la relativement droit de grandeur).

Voici une démonstration (depuis le gif ci-dessous):
- Le minimum est où la star est, et les courbes sont les lignes de contour. (Pour une explication sur les lignes de contour et pourquoi ils sont perpendiculaires à la pente, voir des vidéos Un et Deux par le légendaire 3Blue1Brown.)
- Le (long) flèche violette est la dynamique sous-étape.
- La transparence de la flèche rouge est le gradient de la sous-étape si elle commence avant la dynamique sous-étape.
- La flèche noire est le gradient de la sous-étape si elle démarre après l'élan de la sous-étape.
- CM de la cible de l'obscurité flèche rouge.
- De RAPPEL de l'objectif de la flèche noire.
Noter que cet argument pour expliquer pourquoi NAG est mieux, c'est indépendant du fait que l'algorithme est proche du minimum.

En général, à la fois BOURRIN et CM ont souvent le problème de l'accumulation de plus d'élan que ce qui est bon pour eux, afin que, lorsqu'ils doivent changer de direction, ils ont l'embarras de "temps de réponse". L'avantage de NAG plus de CM que nous avons expliqué n'empêche pas le problème, mais ne fait que le "temps de réponse" de NAG moins gênant (mais gênant quand même).

Ce "temps de réponse" problème est magnifiquement démontré dans le gif par Alec Radford (qui est apparu dans Salvador Dali répondre):

ADAGRAD

(Basée principalement sur l'article 2.2.2 de l' ADADELTA: Un Apprentissage Adaptatif Méthode du Taux d' (l'original ADADELTA papier), car je trouve qu'il est beaucoup plus accessible que Adaptative Subgradient Méthodes pour l'Apprentissage en Ligne et Optimisation Stochastique (l'original ADAGRAD papier).)

Dans SGD, l'étape est donné par - learning_rate * gradient, tandis que learning_rate est un hyper-paramètre.

ADAGRAD a aussi un learning_rate hyper-paramètre, mais le taux pour chaque composante du gradient est calculé individuellement.

Le i-ème composante de la t-ème étape est donnée par:
```
              learning_rate 
- --------------------------------------- * gradient_i_t
  norm((gradient_i_1, ..., gradient_i_t))
```
tout:
- gradient_i_k est le i-ème composante du gradient dans la k-ème étape
- (gradient_i_1, ..., gradient_i_t) est un vecteur avec t composants. Ce n'est pas intuitive (au moins pour moi) que la construction d'un vecteur de sens, mais c'est ce que l'algorithme n' (conceptuellement).
- norm(vector) est le Eucldiean norme (aka l2 norme) de vector, qui est notre notion intuitive de la longueur de vector.
- Point de prêter à confusion, dans ADAGRAD (ainsi que dans certains autres méthodes), l'expression qui est multiplié par gradient_i_t (dans ce cas, learning_rate /norm(...)) est souvent appelé "le taux d'apprentissage" (en fait, je l'ai appelé "le réel au taux d'apprentissage" dans le paragraphe précédent). Je suppose que c'est parce que dans SGD la learning_rate hyper-paramètre et cette expression sont un et le même.
- Dans une véritable mise en œuvre, certaines constante serait ajouté au dénominateur, pour éviter une division par zéro.
E. g. si:
- La i-ème composante du gradient dans la première étape est 1.15
- La i-ème composante du gradient dans la deuxième étape est 1.35
- La i-ème composante du gradient dans la troisième étape est 0.9
Alors la norme de (1.15, 1.35, 0.9) est la longueur de la ligne jaune, qui est:

sqrt(1.15^2 + 1.35^2 + 0.9^2) = 1.989.

Et donc, la i-ème composante de la troisième étape est la suivante: - learning_rate /1.989 * 0.9

Remarque deux choses à propos de la i-ème composante de l'étape:
1. Elle est proportionnelle à learning_rate.
2. Dans les calculs, la norme est à la hausse, et donc le taux d'apprentissage est à la baisse.
Cela signifie que ADAGRAD est sensible au choix de l'hyper-paramètre learning_rate.

En outre, il se peut qu'après un certain temps les étapes deviennent si petits, que ADAGRAD presque coince.

ADADELTA et RMSProp

De la ADADELTA papier:

L'idée présentée dans ce document a été dérivée à partir de ADAGRAD dans le but d'améliorer les deux principaux inconvénients
de la méthode: 1) la constante de désintégration de l'apprentissage
tout au long de la formation, et 2) la nécessité d'une sélection manuelle
apprentissage global de taux.

Le papier, puis explique une amélioration qui vise à s'attaquer à la première inconvénient:

Au lieu d'accumuler la somme des carrés des gradients sur tous les
temps, nous avons limité la fenêtre de passé gradients qui sont accumulés
pour être certains de taille fixe w [...]. Cela garantit que l'apprentissage continue
pour faire des progrès, même après un nombre d'itérations de mises à jour
été fait.

Depuis le stockage w précédente carré gradients est inefficace,
nos méthodes implémente cette accumulation comme une façon exponentielle
la décomposition de la moyenne du carré de la dégradés de.

Par "de façon exponentielle en décomposition moyenne du carré de la dégradés de" le papier signifie que pour chaque i on calcule une moyenne pondérée de l'ensemble du carré de la i-th composants de tous les gradients calculés.

Le poids de chaque carré i-ème composante est plus grande que le poids du carré de la i-ème composante de l'étape précédente.

C'est une approximation d'une fenêtre de taille w parce que le poids dans les étapes précédentes sont très petites.

(Quand je pense à ce sujet d'une manière exponentielle en décomposition moyenne, je tiens à visualiser un la comète trail, qui devient et gradateur dimmer qu'il obtient plus de la comète:

)

Si vous faites seulement ce changement de ADAGRAD, alors vous aurez RMSProp, qui est une méthode qui a été proposée par Geoff Hinton dans Conférence 6e de sa Coursera Classe.

Donc dans RMSProp, le i-ème composante de la t-ème étape est donnée par:
```
                   learning_rate
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon)
```
tout:
- epsilon est un hyper-paramètre qui empêche la division par zéro.
- exp_decay_avg_of_squared_grads_i est une façon exponentielle en décomposition moyenne du carré de la i-th composants de tous les gradients calculés (y compris gradient_i_t).
Mais comme mentionné ci-dessus, ADADELTA vise également à se débarrasser de la learning_rate hyper-paramètre, donc il doit y avoir plus de choses qui se passent en elle.

Dans ADADELTA, le i-ème composante de la t-ème étape est donnée par:
```
  sqrt(exp_decay_avg_of_squared_steps_i + epsilon)
- ------------------------------------------------ * gradient_i_t
  sqrt(exp_decay_avg_of_squared_grads_i + epsilon) 
```
tout exp_decay_avg_of_squared_steps_i est une façon exponentielle en décomposition moyenne du carré de la i-th composants de toutes les étapes de calcul (jusqu'à ce que le t-1-ème étape).

sqrt(exp_decay_avg_of_squared_steps_i + epsilon) est quelque peu similaire à l'élan, et selon le papier, il "agit comme une accélération terme". (Le document donne aussi une autre raison pour laquelle il a été ajouté, mais ma réponse est déjà trop long, donc si vous êtes curieux, consultez la section 3.2).

Adam

(Basée principalement sur les Adam: Une Méthode d'Optimisation Stochastique, l'Adam originel de papier.)

Adam est court pour le Moment d'Estimation (voir cette réponse pour une explication sur le nom).

Le i-ème composante de la t-ème étape est donnée par:
```
                   learning_rate
- ------------------------------------------------ * exp_decay_avg_of_grads_i
  sqrt(exp_decay_avg_of_squared_grads_i) + epsilon
```
tout:
- exp_decay_avg_of_grads_i est une façon exponentielle en décomposition moyenne du i-th composants de tous les gradients calculés (y compris gradient_i_t).
- En fait, les deux exp_decay_avg_of_grads_i et exp_decay_avg_of_squared_grads_i sont également corrigés pour tenir compte d'un biais vers 0 (pour en savoir plus à ce sujet, voir la section 3 dans le papier, et aussi une réponse dans les stats.stackexchange).
Noter que Adam utilise d'une manière exponentielle en décomposition moyenne du i-th composants de la dégradés où la plupart des SGD méthodes utilisent la i-ème composante du courant de gradient. Cela provoque Adam à se comporter comme "une balle lourde avec frottement", comme expliqué dans l'étude GANs Formés par Deux Fois à l'Échelle Règle de mise à Jour Converger à un Équilibre de Nash.

Voir cette réponse pour en savoir plus sur la façon d'Adam essor, comme le comportement est différent de l'habituel l'élan comme comportement.
- Excellente Réponse!!
- Très sous-estimée réponse; mérite plus upvotes. Aussi merci pour diriger les gens 3Blue1Brown. C'est un beau beau enseignant, animateur, mathématiques et penseur
InformationsquelleAutor Oren Milman
2

Laissez bouillir vers le bas d'un couple de question simple:

Qui optimiseur de me donner le meilleur résultat à l'exactitude de la?

Il n'y a pas de solution miracle. Certains optimiseurs pour votre tâche serait sans doute mieux que les autres. Il n'y a aucun moyen de dire à l'avance, vous essayez de chercher un peu pour trouver la meilleure solution. La bonne nouvelle, c'est que les résultats des différents optimiseurs serait probablement proches les uns des autres. Vous devez trouver le meilleur hyperparameters pour un optimiseur de vous choisissez, cependant.

Qui optimiseur doit-je utiliser dès maintenant?

Peut-être, prendre AdamOptimizer et l'exécuter pour learning_rate 0,001 et à 0,0001. Si vous voulez de meilleurs résultats, essayez de fonctionnement pour d'autres l'apprentissage. Ou d'essayer d'autres optimiseurs et de raffiner leurs hyperparameters.

Longue histoire

Il y a quelques aspects à considérer lors du choix de votre optimizer:
- Facile d'utilisation (c'est à dire à quelle vitesse vous pouvez trouver les paramètres qui fonctionnent pour vous);
- Vitesse de Convergence (de base comme SGD ou plus rapide que tout autre);
- Empreinte mémoire (généralement entre 0 et x2 tailles de votre modèle);
- Rapport à d'autres parties du processus de formation.
Plaine SGD est le strict minimum que l'on peut faire: simplement, il multiplie les gradients par le taux d'apprentissage et ajoute le résultat à la pondération. SGD a un certain nombre de belles qualités: il a seulement 1 hyper-paramètre; il n'a pas besoin de mémoire supplémentaire; il a peu d'effet sur les autres parties de la formation. Il dispose également de 2 inconvénients: il est peut-être trop sensible à l'apprentissage du choix d'un taux et de la formation peut prendre plus de temps qu'avec d'autres méthodes.

De ces inconvénients de la plaine SGD nous pouvons voir ce qui est le plus compliqué des règles de mise à jour (optimiseurs) sont pour: - on sacrifier une partie de notre mémoire afin d'atteindre plus rapidement la formation et, éventuellement, de simplifier le choix de hyperparameters.

Surcharge de la mémoire est généralement non significative et peut être ignoré. À moins que le modèle est très grand, ou vous êtes de formation sur la GTX760, ou la lutte pour ImageNet leadership. Des méthodes plus simples comme le momentum ou Nesterov a accéléré gradient besoin de 1,0 ou moins de la taille du modèle (taille du modèle hyperparameters). Deuxième modes de commande (Adam, peut-être besoin de deux fois plus de mémoire et de calcul.

Vitesse de Convergence-sage à peu près tout est mieux que le SGD et rien d'autre est dur de comparer. Une remarque peut-être que AdamOptimizer est bon de départ de la formation presque immédiatement, sans échauffement.

Je considère facile d'utilisation être le plus important dans le choix de l'optimiseur. Différents optimiseurs ont un nombre différent de hyperparameters et ont une sensibilité différente à la leur. Je considère Adam le plus simple de tous facilement disponibles. Généralement, vous devez vérifier 2-4 learning_rates entre 0.001 et 0.0001 pour savoir si le modèle converge bien. Pour la comparaison de SGD (et dynamique), j'essaie généralement [0.1, 0.01, ... 10e-5]. Adam a 2 plus hyperparameters que rarement changé.

Relation entre l'optimiseur et d'autres parties de la formation. Hyper-paramètre de réglage consiste généralement à sélectionner {learning_rate, weight_decay, batch_size, droupout_rate} simultanément. Ils sont tous interdépendants et chacun d'eux peut être considéré comme une forme de modèle de régularisation. On a, par exemple, de porter une attention particulière si, exactement, weight_decay ou L2-norme est utilisée et éventuellement choisir AdamWOptimizer au lieu de AdamOptimizer.

InformationsquelleAutor y.selivonchyk

Vous devez vous connecter pour publier un commentaire.

Classique de la quantité de mouvement (CM) vs Nesterov Accéléré de Gradient (NAG)

ADAGRAD

ADADELTA et RMSProp

Adam

Longue histoire