Relu vs Sigmoid vs Softmax en tant que neurones de couche cachés


22

Je jouais avec un simple réseau neuronal avec une seule couche cachée, par Tensorflow, puis j'ai essayé différentes activations pour la couche cachée:

  • Relu
  • Sigmoïde
  • Softmax (enfin, habituellement softmax est utilisé dans la dernière couche ..)

Relu offre la meilleure précision de train et précision de validation. Je ne sais pas comment expliquer cela.

Nous savons que Relu a de bonnes qualités, comme la rareté, comme la disparition sans gradient, etc., mais

Q: Les neurones Relu sont-ils généralement meilleurs que les neurones sigmoïdes / softmax? Faut-il presque toujours utiliser les neurones Relu dans NN (ou même CNN)? Je pensais qu'un neurone plus complexe introduirait de meilleurs résultats, du moins la précision du train si nous nous inquiétons du sur-ajustement.

Merci PS: Le code provient essentiellement de "Udacity-Machine learning -assignment2", qui est la reconnaissance de notMNIST à l'aide d'un simple NN à 1 couche cachée.

batch_size = 128
graph = tf.Graph()
with graph.as_default():
  # Input data. 
  tf_train_dataset = tf.placeholder(tf.float32, shape=(batch_size, image_size * image_size))
  tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
  tf_valid_dataset = tf.constant(valid_dataset)
  tf_test_dataset = tf.constant(test_dataset)

  # hidden layer
  hidden_nodes = 1024
  hidden_weights = tf.Variable( tf.truncated_normal([image_size * image_size, hidden_nodes]) )
  hidden_biases = tf.Variable( tf.zeros([hidden_nodes]))
  hidden_layer = **tf.nn.relu**( tf.matmul( tf_train_dataset, hidden_weights) + hidden_biases)

  # Variables.
  weights = tf.Variable( tf.truncated_normal([hidden_nodes, num_labels])) 
  biases = tf.Variable(tf.zeros([num_labels]))

  # Training computation.
  logits = tf.matmul(hidden_layer, weights) + biases
  loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels) )

  # Optimizer.
  optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)

  # Predictions for the training, validation, and test data.
  train_prediction = tf.nn.softmax(logits)
  valid_relu = **tf.nn.relu**(  tf.matmul(tf_valid_dataset, hidden_weights) + hidden_biases)
  valid_prediction = tf.nn.softmax( tf.matmul(valid_relu, weights) + biases) 

  test_relu = **tf.nn.relu**( tf.matmul( tf_test_dataset, hidden_weights) + hidden_biases)
  test_prediction = tf.nn.softmax(tf.matmul(test_relu, weights) + biases)

Réponses:


12

En plus de @Bhagyesh_Vikani:

  • Relu se comporte près d'une unité linéaire
  • Relu est comme un interrupteur de linéarité. Si vous n'en avez pas besoin, vous le "désactivez". Si vous en avez besoin, vous "l'allumez". Ainsi, nous obtenons les avantages de la linéarité mais nous réservons la possibilité de ne pas l'utiliser complètement.
  • Le dérivé est 1 lorsqu'il est actif. La dérivée seconde de la fonction est 0 presque partout. C'est donc une fonction très simple. Cela rend l'optimisation beaucoup plus facile.
  • Le dégradé est grand quand vous le voulez et jamais saturé

Il existe également des généralisations d'unités linéaires rectifiées. Les unités linéaires rectifiées et ses généralisations sont basées sur le principe que les modèles linéaires sont plus faciles à optimiser.

Les deux sigmoid / softmax sont déconseillés (chapitre 6: Ian Goodfellow) pour la mise en œuvre de la rétroaction à la vanille. Ils sont plus utiles pour les réseaux récurrents, les modèles probabilistes et certains auto-encodeurs ont des exigences supplémentaires qui excluent l'utilisation de fonctions d'activation linéaires par morceaux.

Si vous avez un NN simple (c'est la question), Relu est votre première préférence .


5

Relu a ses avantages et ses inconvénients:

Avantages:
1. Ne sature pas (dans la région + ve)
2. Calcul, il est très efficace
3. Généralement, les modèles avec des neurones relu convergent beaucoup plus rapidement que les neurones avec d'autres fonctions d'activation, comme décrit ici

Inconvénients:
1. Un problème avec eux est de savoir où ils meurent, c.-à-d. Relus mort. Parce que si l'activation de n'importe quel neurone relu devient nulle, ses gradients seront coupés à zéro en rétropropagation. Cela peut être évité si nous sommes très prudents avec l'initialisation des poids et le réglage du taux d'apprentissage.

Pour plus de détails: consultez cette conférence-5 de CS231n


Il convient de noter que les unités ELU échangent l'efficacité de calcul pour l'immortalité - l'immunité à la mort. arxiv.org/abs/1511.07289
Sycorax dit de réintégrer Monica le

Merci d'avoir intégré cela. Oui, ELU peut être utilisé, mais la raison pour laquelle les RELU sont toujours populaires et utilisées par rapport à ELU est que, tout en utilisant ELU, un nouveau hyper-paramètre est introduit.
Bhagyesh Vikani

1
Il y a essentiellement aucune raison que vous avez à accorder sur ce paramètre particulier.
Sycorax dit Réintégrer Monica le

4

http://cs231n.github.io/neural-networks-1/

Sigmoids

Les sigmoides saturent et tuent les dégradés. Les sorties sigmoïdes ne sont pas centrées sur zéro.

tanh

Comme le neurone sigmoïde, ses activations saturent, mais contrairement au neurone sigmoïde, sa sortie est centrée sur zéro. Par conséquent, dans la pratique, la non-linéarité tanh est toujours préférée à la non-linéarité sigmoïde.

ReLU

Utilisez la non-linéarité ReLU, soyez prudent avec vos taux d'apprentissage et surveillez éventuellement la fraction d'unités «mortes» dans un réseau. Si cela vous concerne, essayez Leaky ReLU ou Maxout. N'utilisez jamais de sigmoïde. Essayez tanh, mais attendez-vous à ce qu'il fonctionne moins bien que ReLU / Maxout.


2
Je ne comprends pas comment sigmoïde et tanh sont significativement différents, lorsque les nœuds de biais peuvent se déplacer l'un vers le haut ou vers le bas pour ressembler à l'autre.
endolith
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.