Relu vs Sigmoid vs Softmax come neuroni a strati nascosti

Stavo giocando con una semplice rete neurale con un solo livello nascosto, di Tensorflow, e poi ho provato diverse attivazioni per il livello nascosto:

• Relu
• sigmoid
• Softmax (beh, di solito softmax è usato nell'ultimo strato ..)

Relu offre la migliore precisione e accuratezza di convalida del treno. Non sono sicuro di come spiegarlo.

Sappiamo che Relu ha buone qualità, come la scarsità, come la sparizione senza gradiente, ecc., Ma

D: Il neurone Relu è generalmente migliore dei neuroni sigmoidi / softmax? Dovremmo quasi sempre usare i neuroni Relu nella NN (o anche nella CNN)? Pensavo che un neurone più complesso avrebbe introdotto risultati migliori, almeno allenando l'accuratezza se ci preoccupiamo di un eccesso di adattamento.

Grazie PS: il codice deriva essenzialmente da "Udacity-Machine learning -assignment2", che è il riconoscimento di notMNIST usando un semplice NN a 1 strato nascosto.

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)

Oltre a @Bhagyesh_Vikani:

• Relu si comporta vicino a un'unità lineare
• Relu è come un interruttore per la linearità. Se non ti serve, lo "spegni". Se ne hai bisogno, lo "accendi". Pertanto, otteniamo i vantaggi della linearità ma ci riserviamo un'opzione di non utilizzarlo ulteriormente.
• La derivata è 1 quando è attiva. La seconda derivata della funzione è 0 quasi ovunque. Pertanto, è una funzione molto semplice. Ciò rende l'ottimizzazione molto più semplice.
• Il gradiente è grande ogni volta che lo desideri e non saturi mai

Esistono anche generalizzazioni di unità lineari rettificate. Le unità lineari rettificate e le sue generalizzazioni si basano sul principio secondo cui i modelli lineari sono più facili da ottimizzare.

Sia sigmoid / softmax sono scoraggiati (capitolo 6: Ian Goodfellow) per l'implementazione feedforward della vaniglia. Sono più utili per le reti ricorrenti, i modelli probabilistici e alcuni autocodificatori hanno requisiti aggiuntivi che escludono l'uso di funzioni di attivazione lineare a tratti.

Se hai un semplice NN (questa è la domanda), Relu è la tua prima preferenza .

Relu ha i suoi pro e contro:

Pro:
1. Non saturare (nella + ve regione)
2. Computazionalmente, è molto efficiente
3. Generalmente i modelli con neuroni relu convergono molto più velocemente dei neuroni con altre funzioni di attivazione, come descritto qui

Contro:
1. Un problema nel trattare con loro è dove muoiono, cioè Relus morto. Perché se l'attivazione di qualsiasi neurone relu diventa zero, i suoi gradienti verranno ritagliati a zero nella retro-propagazione. Questo può essere evitato se prestiamo molta attenzione all'inizializzazione dei pesi e alla regolazione del tasso di apprendimento.

Per maggiori dettagli: controlla questa lezione-5 di CS231n

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

sigmoidi

I sigmoidi saturano e uccidono i gradienti. Le uscite Sigmoid non sono centrate sullo zero.

tanh

Come il neurone sigmoideo, le sue attivazioni sono saturate, ma a differenza del neurone sigmoideo la sua uscita è centrata sullo zero. Pertanto, in pratica la non linearità del tanh è sempre preferita alla non linearità sigmoidea.

Relu

Usa la non linearità ReLU, fai attenzione ai tuoi tassi di apprendimento e, eventualmente, controlla la frazione di unità "morte" in una rete. Se questo ti riguarda, prova Leaky ReLU o Maxout. Non usare mai sigmoid. Prova tanh, ma aspettati che funzioni peggio di ReLU / Maxout.