Relu vs Sigmoid vs Softmax como neuronas de capa oculta

Estaba jugando con una red neuronal simple con una sola capa oculta, por Tensorflow, y luego probé diferentes activaciones para la capa oculta:

• Relu
• Sigmoideo
• Softmax (bueno, generalmente softmax se usa en la última capa ..)

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

Sabemos que Relu tiene buenas cualidades, como la escasez, como la desaparición sin gradiente, etc., pero

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

Gracias PD: El código es básicamente de "Udacity-Machine learning -assignment2", que es el reconocimiento de notMNIST usando un 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)

Además de @Bhagyesh_Vikani:

• Relu se comporta cerca de una unidad lineal
• Relu es como un interruptor para la linealidad. Si no lo necesita, lo "apaga". Si lo necesita, lo "enciende". Por lo tanto, obtenemos los beneficios de linealidad, pero nos reservamos la opción de no usarlo por completo.
• 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 desee y nunca se sature

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.

Se desaconseja tanto sigmoid / softmax (capítulo 6: Ian Goodfellow) para la implementación de avance de vainilla. Son más útiles para redes recurrentes, modelos probabilísticos y algunos autoencoders tienen requisitos adicionales que descartan el uso de funciones de activación lineal por partes.

Si tiene un NN simple (esa es la pregunta), Relu es su primera preferencia .

Relu tiene sus propios pros y contras:

Pros:
1. No 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, Relus muertos. Porque si la activación de cualquiera de las neuronas relu se vuelve cero, entonces sus gradientes se recortarán a cero en la retropropagación. Esto se puede evitar si tenemos mucho cuidado con la inicialización de pesos y la tasa de aprendizaje de ajuste.

Para más detalles: consulte esta conferencia-5 de CS231n

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

Sigmoides

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

tanh

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

ReLU

Utilice la no linealidad 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 Leaky ReLU o Maxout. Nunca use sigmoide. Intente tanh, pero espere que funcione peor que ReLU / Maxout.