Relu vs Sigmoid vs Softmax jako neurony z ukrytą warstwą

Bawiłem się prostą siecią neuronową z tylko jedną ukrytą warstwą, autorstwa Tensorflow, a następnie próbowałem różnych aktywacji dla ukrytej warstwy:

• Relu
• Sigmoid
• Softmax (cóż, zwykle softmax jest używany w ostatniej warstwie ..)

Relu zapewnia najlepszą dokładność pociągu i dokładność walidacji. Nie jestem pewien, jak to wyjaśnić.

Wiemy, że Relu ma dobre cechy, takie jak rzadkość, takie jak znikanie bez gradientu itp., Ale

P: Czy neuron Relu jest ogólnie lepszy niż neurony sigmoidalne / softmax? Czy prawie zawsze powinniśmy używać neuronów Relu w NN (a nawet CNN)? Myślałem, że bardziej złożony neuron wprowadziłby lepszy wynik, przynajmniej dokładność pociągu, jeśli martwimy się o nadmierne dopasowanie.

Dzięki PS: Kod w zasadzie pochodzi z „Udacity-Machine learning -assignment2”, który jest rozpoznaniem notMNIST za pomocą prostej 1-ukrytej warstwy-NN.

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)

Oprócz @Bhagyesh_Vikani:

• Relu zachowuje się w pobliżu jednostki liniowej
• Relu jest jak przełącznik liniowości. Jeśli go nie potrzebujesz, „wyłączasz”. Jeśli potrzebujesz, „włączasz”. W ten sposób uzyskujemy korzyści z liniowości, ale zastrzegamy sobie opcję nieużywania go całkowicie.
• Pochodna ma wartość 1, gdy jest aktywna. Druga pochodna funkcji wynosi 0 prawie wszędzie. Jest to więc bardzo prosta funkcja. To znacznie ułatwia optymalizację.
• Gradient jest duży, kiedy tylko chcesz, i nigdy się nie nasyca

Istnieją również uogólnienia skorygowanych jednostek liniowych. Zrektyfikowane jednostki liniowe i ich uogólnienia oparte są na zasadzie, że modele liniowe są łatwiejsze do optymalizacji.

Zarówno sigmoid / softmax są odradzane (rozdział 6: Ian Goodfellow) do implementacji przekazywania waniliowego. Są one bardziej przydatne w sieciach cyklicznych, modelach probabilistycznych, a niektóre autoencodery mają dodatkowe wymagania, które wykluczają stosowanie częściowych liniowych funkcji aktywacyjnych.

Jeśli masz proste NN (to jest pytanie), Relu jest twoją pierwszą preferencją .

Relu ma swoje zalety i wady:

Plusy:
1. Nie nasyca (w obszarze + ve)
2. Obliczeniowo, jest bardzo wydajny
3. Ogólnie modele z neuronami relu zbiegają się znacznie szybciej niż neurony z innymi funkcjami aktywacyjnymi, jak opisano tutaj

Minusy:
1. Jednym z problemów z radzeniem sobie z nimi jest to, gdzie umierają, tj. Martwy Relus. Ponieważ jeśli aktywacja któregokolwiek neuronu relu osiągnie zero, wówczas jego gradienty zostaną przycięte do zera podczas propagacji wstecznej. Można tego uniknąć, jeśli będziemy bardzo ostrożni przy inicjowaniu wag i dostosowywaniu szybkości uczenia się.

Aby uzyskać więcej informacji: Sprawdź ten wykład-5 CS231n

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

Sigmoidy

Sigmoidy nasycają i zabijają gradienty. Wyjścia sigmoidalne nie są wyśrodkowane na zero.

tanh

Podobnie jak sigmoidalny neuron, jego aktywacje są nasycone, ale w przeciwieństwie do sigmoidalnego neuronu jego moc wyjściowa jest zerowa. Dlatego w praktyce nieliniowość tanh jest zawsze preferowana w stosunku do nieliniowości sigmoidalnej.

ReLU

Użyj nieliniowości ReLU, uważaj na tempo uczenia się i ewentualnie monitoruj odsetek „martwych” jednostek w sieci. Jeśli dotyczy to Ciebie, wypróbuj Leaky ReLU lub Maxout. Nigdy nie używaj sigmoidu. Spróbuj tanh, ale spodziewaj się, że będzie działać gorzej niż ReLU / Maxout.