Relu vs Sigmoid vs Softmax als versteckte Schicht Neuronen

Ich habe mit einem einfachen neuronalen Netzwerk mit nur einer ausgeblendeten Ebene von Tensorflow gespielt und dann verschiedene Aktivierungen für die ausgeblendete Ebene ausprobiert:

• Relu
• Sigmoid
• Softmax (na ja, normalerweise wird Softmax in der letzten Schicht verwendet.)

Relu bietet die beste Zuggenauigkeit und Validierungsgenauigkeit. Ich bin mir nicht sicher, wie ich das erklären soll.

Wir wissen, dass Relu gute Eigenschaften wie Sparsamkeit hat, wie kein Gradienten-Verschwinden, etc, aber

F: Ist das Relu-Neuron im Allgemeinen besser als Sigmoid / Softmax-Neuronen? Sollten wir fast immer Relu-Neuronen in NN (oder sogar CNN) verwenden? Ich dachte, ein komplexeres Neuron würde ein besseres Ergebnis bringen, zumindest die Genauigkeit des Trainings, wenn wir uns Sorgen über eine Überanpassung machen.

Danke PS: Der Code stammt im Wesentlichen aus "Udacity-Machine Learning-Assignment2", was die Erkennung von notMNIST mit einem einfachen 1-Hidden-Layer-NN bedeutet.

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)

Zusätzlich zu @Bhagyesh_Vikani:

• Relu verhält sich in der Nähe einer Lineareinheit
• Relu ist wie ein Schalter für Linearität. Wenn Sie es nicht brauchen, "schalten" Sie es aus. Wenn Sie es brauchen, "schalten" Sie es ein. Somit erhalten wir die Linearitätsvorteile, behalten uns jedoch die Option vor, sie nicht vollständig zu verwenden.
• Die Ableitung ist 1, wenn sie aktiv ist. Die zweite Ableitung der Funktion ist fast überall 0. Somit ist es eine sehr einfache Funktion. Das erleichtert die Optimierung erheblich.
• Der Farbverlauf ist groß, wann immer Sie möchten und nie gesättigt

Es gibt auch Verallgemeinerungen von gleichgerichteten Lineareinheiten. Gleichgerichtete Lineareinheiten und ihre Verallgemeinerungen basieren auf dem Prinzip, dass lineare Modelle einfacher zu optimieren sind.

Sowohl sigmoid / softmax sind abgeraten (Kapitel 6: Ian Goodfellow) für Vanille Vors Implementierung. Sie sind nützlicher für wiederkehrende Netzwerke, Wahrscheinlichkeitsmodelle und einige Autoencoder haben zusätzliche Anforderungen, die die Verwendung stückweise linearer Aktivierungsfunktionen ausschließen.

Wenn Sie eine einfache NN haben (das ist die Frage), ist Relu Ihre erste Präferenz .

Relu hat seine eigenen Vor- und Nachteile:

Vorteile:
1. Sättigt nicht (in + ve Region)
2. Computerisch ist es sehr effizient
3. Im Allgemeinen konvergieren Modelle mit relu-Neuronen viel schneller als Neuronen mit anderen Aktivierungsfunktionen, wie hier beschrieben

Nachteile:
1. Ein Problem beim Umgang mit ihnen ist, wo sie sterben, dh tot Relus. Denn wenn die Aktivierung eines Relu-Neurons Null wird, werden seine Gradienten bei der Rückausbreitung auf Null begrenzt. Dies kann vermieden werden, wenn wir bei der Initialisierung der Gewichte und der Optimierung der Lernrate sehr vorsichtig sind.

Für weitere Details: Überprüfen Sie diese Vorlesung-5 von CS231n

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

Sigmoiden

Sigmoide sättigen und töten Farbverläufe. Sigmoid-Ausgänge sind nicht nullzentriert.

Tanh

Wie das Sigmoid-Neuron sättigen sich seine Aktivierungen, aber im Gegensatz zum Sigmoid-Neuron ist sein Ausgang auf Null zentriert. In der Praxis wird daher die tanh-Nichtlinearität immer der sigmoiden Nichtlinearität vorgezogen.

ReLU

Verwenden Sie die ReLU-Nichtlinearität, achten Sie auf Ihre Lernraten und überwachen Sie möglicherweise den Anteil der "toten" Einheiten in einem Netzwerk. Wenn dies Sie betrifft, versuchen Sie es mit Leaky ReLU oder Maxout. Verwenden Sie niemals Sigmoid. Versuchen Sie Tanh, aber erwarten Sie, dass es schlechter als ReLU / Maxout funktioniert.