Relu vs Sigmoid vs Softmax sebagai neuron lapisan tersembunyi

Saya bermain dengan Neural Network sederhana dengan hanya satu lapisan tersembunyi, oleh Tensorflow, dan kemudian saya mencoba berbagai aktivasi untuk lapisan tersembunyi:

• Relu
• Sigmoid
• Softmax (well, biasanya softmax digunakan di lapisan terakhir ..)

Relu memberikan akurasi kereta terbaik & akurasi validasi. Saya tidak yakin bagaimana menjelaskannya.

Kita tahu bahwa Relu memiliki kualitas yang baik, seperti sparsity, seperti no-gradient-vanishing, dll

T: apakah neuron relu secara umum lebih baik daripada neuron sigmoid / softmax? Haruskah kita hampir selalu menggunakan neuron Relu di NN (atau bahkan CNN)? Saya pikir neuron yang lebih kompleks akan memberikan hasil yang lebih baik, setidaknya melatih akurasi jika kita khawatir tentang overfitting.

Terima kasih PS: Pada dasarnya kode ini dari "Udacity-Machine learning -assignment2", yang merupakan pengakuan notMNIST menggunakan 1-hidden-layer-NN yang sederhana.

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)

Selain @ Bhagyesh_Vikani:

• Relu berperilaku dekat dengan unit linier
• Relu seperti saklar untuk linearitas. Jika Anda tidak membutuhkannya, Anda "matikan". Jika Anda membutuhkannya, Anda "aktifkan". Dengan demikian, kita mendapatkan manfaat linearitas tetapi mencadangkan pilihan untuk tidak menggunakan altogther.
• Turunannya adalah 1 saat aktif. Turunan kedua dari fungsi adalah 0 hampir di mana-mana. Jadi, ini adalah fungsi yang sangat sederhana. Itu membuat optimasi lebih mudah.
• Gradien besar kapan pun Anda mau dan tidak pernah jenuh

Ada juga generalisasi unit linear yang diperbaiki. Unit linier yang diperbaiki dan generalisasi didasarkan pada prinsip bahwa model linier lebih mudah untuk dioptimalkan.

Kedua sigmoid / softmax tidak disarankan (bab 6: Ian Goodfellow) untuk implementasi feed vanward . Mereka lebih berguna untuk jaringan berulang, model probabilistik, dan beberapa autoencoder memiliki persyaratan tambahan yang mengesampingkan penggunaan fungsi aktivasi linier piecewise.

Jika Anda memiliki NN sederhana (itu pertanyaannya), Relu adalah pilihan pertama Anda .

Relu memiliki pro dan kontra sendiri:

Kelebihan:
1. Tidak jenuh (di + ve wilayah)
2. Secara komputasi, ini sangat efisien
3. Secara umum model dengan relu neuron bertemu jauh lebih cepat daripada neuron dengan fungsi aktivasi lainnya, seperti dijelaskan di sini

Cons:
1. Satu masalah dengan berurusan dengan mereka adalah di mana mereka mati, yaitu Relus mati. Karena jika aktivasi setiap relu neuron menjadi nol maka gradiennya akan terpotong menjadi nol dalam propagasi balik. Ini dapat dihindari jika kita sangat berhati-hati dengan inisialisasi bobot dan tingkat pembelajaran tuning.

Untuk lebih jelasnya: Lihat kuliah-5 ini dari CS231n

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

Sigmoids

Sigmoids menjenuhkan dan membunuh gradien. Output Sigmoid tidak berpusat nol.

tanh

Seperti halnya neuron sigmoid, aktivasinya jenuh, tetapi tidak seperti neuron sigmoid, outputnya berpusat nol. Oleh karena itu, dalam praktiknya tan-non-linearitas selalu lebih disukai daripada nonlinearitas sigmoid.

ReLU

Gunakan ReLU non-linearitas, berhati-hatilah dengan tingkat belajar Anda dan mungkin memantau fraksi unit "mati" dalam jaringan. Jika ini menyangkut Anda, cobalah Leaky ReLU atau Maxout. Jangan pernah gunakan sigmoid. Coba tanh, tetapi berharap itu bekerja lebih buruk daripada ReLU / Maxout.