Relu vs Sigmoid vs Softmax como neuronas de la capa oculta

Question

Estuve jugando con una simple Red Neural con una sola capa oculta, por Tensorflow, y luego probé diferentes activaciones para la capa oculta:

• Relu
• Sigmoide
• Softmax (bueno, normalmente softmax se utiliza en la última capa..)

Relu ofrece la mejor precisión de entrenamiento y de validación. No estoy seguro de cómo explicar esto.

Sabemos que Relu tiene buenas cualidades, como la dispersión, como el no-gradiente-vanishing, etc, pero

P: ¿es la neurona Relu en general mejor que las neuronas sigmoides/softmax? ¿Deberíamos utilizar casi siempre neuronas Relu en las NN (o incluso en las CNN)? Pensé que una neurona más compleja introduciría un mejor resultado, al menos la precisión del tren si nos preocupamos por el sobreajuste.

Gracias PD: El código básicamente es de "Udacity-Machine learning -assignment2", que es el reconocimiento de notMNIST usando una simple NN de 1 capa oculta.

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)

Answer 1

Además de @Bhagyesh_Vikani:

• Relu se comporta como una unidad lineal
• Relu es como un interruptor para la linealidad. Si no lo necesitas, lo "desconectas". Si lo necesitas, lo "enciendes". Así, obtenemos las ventajas de la linealidad pero nos reservamos la opción de no utilizarla.
• La derivada es 1 cuando está activa. La segunda derivada de la función es 0 en casi todas partes. Por lo tanto, es una función muy simple. Eso hace que la optimización sea mucho más fácil.
• El gradiente es grande siempre que lo desees y nunca se satura

También hay generalizaciones de unidades lineales rectificadas. Las unidades lineales rectificadas y sus generalizaciones se basan en el principio de que los modelos lineales son más fáciles de optimizar.

Tanto el sigmoide como el softmax son desanimado (capítulo 6: Ian Goodfellow) para la implementación de vainilla feedforward. Son más útiles para las redes recurrentes, los modelos probabilísticos y algunos autocodificadores tienen requisitos adicionales que descartan el uso de funciones de activación lineal a trozos.

Si tienes una NN sencilla (esa es la cuestión), Relu es tu primera preferencia .

Answer 2

Relu tienen sus propios pros y contras:

Pros:
1. No se satura (en la región +ve)
2. Computacionalmente, es muy eficiente
3. En general, los modelos con neuronas relu convergen mucho más rápido que las neuronas con otras funciones de activación, como se describe aquí

Contras:
1. Un problema al tratar con ellos es dónde mueren, es decir, los Relus muertos. Porque si la activación de cualquier neurona relu llega a ser cero entonces sus gradientes serán recortados a cero en la retropropagación. Esto puede evitarse si somos muy cuidadosos con la inicialización de los pesos y el ajuste de la tasa de aprendizaje.

Para más detalles: Compruebe esto Conferencia-5 de CS231n

Answer 3

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

Sigmoides

Los sigmoides saturan y matan los gradientes. Las salidas sigmoides no están centradas en el cero.

tanh

Al igual que la neurona sigmoidea, sus activaciones se saturan, pero a diferencia de ésta su salida está centrada en el cero. Por lo tanto, en la práctica siempre se prefiere la no linealidad tanh a la no linealidad sigmoide.

ReLU

Utilice la no linealidad de ReLU, tenga cuidado con sus tasas de aprendizaje y posiblemente controle la fracción de unidades "muertas" en una red. Si esto le preocupa, pruebe con Leaky ReLU o Maxout. No utilice nunca la sigmoidea. Pruebe tanh, pero espere que funcione peor que ReLU/Maxout.