Estaba jugando con una red neuronal simple con una sola capa oculta, por Tensorflow, y luego probé diferentes activaciones para la capa oculta:
- Relu
- Sigmoideo
- Softmax (bueno, generalmente softmax se usa en la última capa ..)
Relu ofrece la mejor precisión de tren y precisión de validación. No estoy seguro de cómo explicar esto.
Sabemos que Relu tiene buenas cualidades, como la escasez, como la desaparición sin gradiente, etc., pero
P: ¿la neurona Relu en general es mejor que las neuronas sigmoides / softmax? ¿Deberíamos usar casi siempre neuronas Relu en NN (o incluso CNN)? Pensé que una neurona más compleja introduciría mejores resultados, al menos la precisión del entrenamiento si nos preocupamos por el sobreajuste.
Gracias PD: El código es básicamente de "Udacity-Machine learning -assignment2", que es el reconocimiento de notMNIST usando un simple NN de 1 capa 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)
fuente
Respuestas:
Además de @Bhagyesh_Vikani:
También hay generalizaciones de unidades lineales rectificadas. Las unidades lineales rectificadas y sus generalizaciones se basan en el principio de que los modelos lineales son más fáciles de optimizar.
Se desaconseja tanto sigmoid / softmax (capítulo 6: Ian Goodfellow) para la implementación de avance de vainilla. Son más útiles para redes recurrentes, modelos probabilísticos y algunos autoencoders tienen requisitos adicionales que descartan el uso de funciones de activación lineal por partes.
Si tiene un NN simple (esa es la pregunta), Relu es su primera preferencia .
fuente
Relu tiene sus propios pros y contras:
Pros:
1. No satura (en la región + ve)
2. Computacionalmente, es muy eficiente
3. En general, los modelos con neuronas relu convergen mucho más rápido que las neuronas con otras funciones de activación, como se describe aquí
Contras:
1. Un problema al tratar con ellos es dónde mueren, es decir, Relus muertos. Porque si la activación de cualquiera de las neuronas relu se vuelve cero, entonces sus gradientes se recortarán a cero en la retropropagación. Esto se puede evitar si tenemos mucho cuidado con la inicialización de pesos y la tasa de aprendizaje de ajuste.
Para más detalles: consulte esta conferencia-5 de CS231n
fuente
http://cs231n.github.io/neural-networks-1/
Sigmoides
Los sigmoides saturan y matan los gradientes. Las salidas sigmoideas no están centradas en cero.
tanh
Al igual que la neurona sigmoidea, sus activaciones se saturan, pero a diferencia de la neurona sigmoidea, su salida está centrada en cero. Por lo tanto, en la práctica, la no linealidad de tanh siempre se prefiere a la no linealidad sigmoidea.
ReLU
Utilice la no linealidad ReLU, tenga cuidado con sus tasas de aprendizaje y posiblemente controle la fracción de unidades "muertas" en una red. Si esto le preocupa, pruebe Leaky ReLU o Maxout. Nunca use sigmoide. Intente tanh, pero espere que funcione peor que ReLU / Maxout.
fuente