Comment mettre en œuvre weight decay dans tensorflow comme dans Caffe

Dans Caffe, nous avons une decay_ratio qui est généralement défini comme 0.0005. Alors tous les moyens paramètres, par exemple, la matrice W dans FC6 sera pourri par:
W = W * (1 - 0.0005)
après, nous avons appliqué le gradient.

Je passe par de nombreux tutoriel tensorflow codes, mais ne voient pas comment les gens de mettre en œuvre ce poids de décroissance pour éviter les problèmes numériques (très grand en valeur absolue)

J'ai mes expériences, j'ai souvent confrontés à des problèmes numériques aften 100 itérations au cours de la formation.

J'ai aussi passer par des questions liées à stackoverflow, par exemple,
Comment définir le poids du coût de la force dans TensorFlow?
Cependant, la solution semble un peu différent mis en œuvre Caffe.

Quelqu'un a les mêmes préoccupations? Merci.

OriginalL'auteur user2868512 | 2016-08-10

3

C'est une double question:

Comment définir le poids de décroissance des couches individuelles dans TensorFlow?
```
# Create your variables
weights = tf.get_variable('weights', collections=['variables'])

with tf.variable_scope('weights_norm') as scope:
  weights_norm = tf.reduce_sum(
  input_tensor = WEIGHT_DECAY_FACTOR*tf.pack(
      [tf.nn.l2_loss(i) for i in tf.get_collection('weights')]
  ),
  name='weights_norm'
)

# Add the weight decay loss to another collection called losses
tf.add_to_collection('losses', weights_norm)

# Add the other loss components to the collection losses     
# ...

# To calculate your total loss
tf.add_n(tf.get_collection('losses'), name='total_loss')
```
Il vous suffit de définir quelle que soit la valeur lambda vous souhaitez le poids de la carie. Le ci-dessus ajoute que la norme 2.

Ne serait pas tf.reduce_mean plus de sens que la somme? Ensuite, le poids de décroissance sera (plus) invariant wrt taille du réseau
Il n'a vraiment pas beaucoup de sens d'utiliser de réduire moyenne comme étant calculée sur la l2 sur le poids. Parce qu'alors, il suggère que chaque vecteur de poids devrait contribuer tout autant que tous les autres mais un peu de poids peut correspondre à un très grand vecteur, tandis que d'autres correspondent à des petits. N'hésitez pas à utiliser et il peut améliorer les performances, je n'ai pas testé les deux approches pour comparer.
J'ai toujours l'impression qu'il est étrange que le poids de décroissance du paramètre doit dépendre du nombre de vecteurs de poids, mais je suis d'accord que l'utilisation de la moyenne a encore moins de sens.
C'est faux (comme dans: pas le même que caffe) pour tout optimiseur d'autres que de pur SGD. Voir la formule dans l'OP, la perte que vous proposez est de même avec les premières SGD, mais quand l'élan et à d'autres fonctions optimiseurs entrent en jeu, votre perte de poids et de désintégration en caffe faire des choses très différentes.

OriginalL'auteur Steven
3

La réponse actuelle est mauvaise en ce qu'elle ne vous donne pas le bon poids "de la décroissance comme dans cuda-convnet/caffe", mais au contraire L2-régularisation, ce qui est différent.

Lors de l'utilisation de pur SGD (sans élan) comme un optimiseur, weight decay est la même chose que l'ajout d'un L2-terme de régularisation à la perte. Lors de l'utilisation de tout autre optimiseur, ce n'est pas vrai.

Weight decay (je ne sais pas comment TeX ici, donc excusez mon pseudo notation):
```
w[t+1] = w[t] - learning_rate * dw - weight_decay * w
```
L2-régularisation:
```
loss = actual_loss + lambda * 1/2 sum(||w||_2 for w in network_params)
```
Le calcul du gradient de la session supplémentaire en L2-régularisation donne lambda * w et donc de l'insérer dans le SGD mise à jour de l'équation
```
dloss_dw = dactual_loss_dw + lambda * w
w[t+1] = w[t] - learning_rate * dw
```
donne le même poids à la carie, mais se mêle lambda avec le learning_rate. Toute autre optimiseur, même SGD avec de l'élan, donne une autre règle de mise à jour pour le poids, la désintégration de L2-régularisation! Voir le document Fixation poids de désintégration dans Adam pour plus de détails. (Edit: autant que je sache, cette 1987 Hinton papier introduit "weight decay", littéralement "à chaque fois que les poids sont mis à jour, leur ampleur est également diminué de 0,4%" à la page 10)

Cela étant dit, il ne semble pas être le soutien de "bon" poids de désintégration dans TensorFlow encore. Il y a quelques questions en discuter, précisément en raison de ce document cité ci-dessus.

Une façon possible de la mettre en œuvre est par l'écriture d'un op qui ne la désintégration de l'étape manuellement après chaque optimiseur de l'étape. Une façon différente, qui est ce que je fais actuellement, est l'utilisation d'un autre SGD optimiseur juste pour le poids de la décomposition, et "attachant" à votre train_op. Ces deux sont juste brut de rechange, cependant. Mon code actuel:
```
# In the network definition:
with arg_scope([layers.conv2d, layers.dense],
               weights_regularizer=layers.l2_regularizer(weight_decay)):
    # define the network.

loss = # compute the actual loss of your problem.
train_op = optimizer.minimize(loss, global_step=global_step)
if args.weight_decay not in (None, 0):
    with tf.control_dependencies([train_op]):
        sgd = tf.train.GradientDescentOptimizer(learning_rate=1.0)
        train_op = sgd.minimize(tf.add_n(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)))
```
Un peu cela rend l'utilisation de TensorFlow la disposition de la comptabilité. Notez que le arg_scope prend soin d'ajouter une L2-terme de régularisation pour chaque couche de la REGULARIZATION_LOSSES graphique-clé, que j'ai ensuite tous les résumer et d'optimiser l'utilisation de SGD, qui, comme indiqué ci-dessus, correspond à le poids réel de désintégration.

Espère que ça aide, et si quelqu'un obtient une belle extrait de code pour cela, ou TensorFlow met en place en mieux (c'est à dire dans les optimiseurs), s'il vous plaît partager.

Edit: voir aussi cette PR qui viens de fusionnés en TF.

OriginalL'auteur LucasB

Vous devez vous connecter pour publier un commentaire.