Relu vs Sigmoid vs Softmax como neurônios da camada oculta


22

Eu estava jogando com uma rede neural simples, com apenas uma camada oculta, da Tensorflow, e tentei diferentes ativações para a camada oculta:

  • Relu
  • Sigmoid
  • Softmax (bem, normalmente o softmax é usado na última camada ..)

Relu oferece a melhor precisão de trem e precisão de validação. Não sei bem como explicar isso.

Sabemos que Relu tem boas qualidades, como escarsidade, como desaparecimento sem gradiente, etc., mas

P: o neurônio Relu em geral é melhor que os neurônios sigmóides / softmáx? Deveríamos quase sempre usar os neurônios Relu no NN (ou até na CNN)? Eu pensei que um neurônio mais complexo apresentaria melhores resultados, pelo menos a precisão do trem, se nos preocuparmos com o ajuste excessivo.

Obrigado PS: O código é basicamente de "Udacity-Machine learning -assignment2", que é o reconhecimento de notMNIST usando um simples NN de 1 camada 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)

Respostas:


12

Além de @Bhagyesh_Vikani:

  • Relu se comporta próximo a uma unidade linear
  • Relu é como uma mudança de linearidade. Se você não precisar, você "desativa". Se você precisar, você "liga". Assim, obtemos os benefícios da linearidade, mas nos reservamos a opção de não usá-los mais.
  • A derivada é 1 quando está ativa. A segunda derivada da função é 0 em quase todos os lugares. Portanto, é uma função muito simples. Isso facilita muito a otimização.
  • O gradiente é grande sempre que você deseja e nunca satura

Também existem generalizações de unidades lineares retificadas. As unidades lineares retificadas e suas generalizações são baseadas no princípio de que os modelos lineares são mais fáceis de otimizar.

Ambos sigmoides / softmáx são desencorajados (capítulo 6: Ian Goodfellow) para a implementação de avanço de baunilha. Eles são mais úteis para redes recorrentes, modelos probabilísticos e alguns codificadores automáticos possuem requisitos adicionais que excluem o uso de funções de ativação linear por partes.

Se você tem um NN simples (eis a questão), Relu é sua primeira preferência .


5

A Relu tem seus próprios prós e contras:

Prós:
1. Não satura (região + ve)
2. Computacionalmente, é muito eficiente
3. Geralmente os modelos com neurônios relu convergem muito mais rápido que os neurônios com outras funções de ativação, conforme descrito aqui

Contras:
1. Um problema em lidar com eles é onde eles morrem, ou seja, Relus morto. Como se a ativação de qualquer neurônio relu se tornar zero, seus gradientes serão reduzidos a zero na propagação traseira. Isso pode ser evitado se tivermos muito cuidado com a inicialização de pesos e a taxa de aprendizado de ajuste.

Para mais detalhes: Confira esta palestra-5 do CS231n


Vale a pena notar que as unidades da ELU trocam eficiência computacional por imortalidade - imunidade à morte. arxiv.org/abs/1511.07289
Sycorax diz restabelecer Monica

Obrigado por incorporar isso. Sim, a ELU pode ser usada, mas a razão pela qual as RELUs ainda são populares e usadas sobre a ELU é porque, ao usar a ELU, um novo hiperparâmetro é introduzido.
Bhagyesh Vikani

1
Não há essencialmente nenhuma razão que você tem de sintonizar sobre esse parâmetro particular.
Sycorax diz Restabelecer Monica

4

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

Sigmoids

Os sigmóides saturam e matam gradientes. As saídas sigmóides não são centralizadas em zero.

tanh

Como o neurônio sigmóide, suas ativações saturam, mas, diferentemente do neurônio sigmóide, sua produção é centrada em zero. Portanto, na prática, a não linearidade de tanh é sempre preferida à não linearidade sigmóide.

ReLU

Use a não linearidade da ReLU, tenha cuidado com suas taxas de aprendizado e, possivelmente, monitore a fração de unidades "mortas" em uma rede. Se isso lhe interessar, experimente o Leaky ReLU ou o Maxout. Nunca use sigmóide. Tente tanh, mas espere que funcione pior que ReLU / Maxout.


2
Eu não entendo como sigmoide e tanh são significativamente diferentes, quando nós de viés podem mudar um para cima ou para baixo para se parecer com o outro.
endolith
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.