Je jouais avec un simple réseau neuronal avec une seule couche cachée, par Tensorflow, puis j'ai essayé différentes activations pour la couche cachée:
- Relu
- Sigmoïde
- Softmax (enfin, habituellement softmax est utilisé dans la dernière couche ..)
Relu offre la meilleure précision de train et précision de validation. Je ne sais pas comment expliquer cela.
Nous savons que Relu a de bonnes qualités, comme la rareté, comme la disparition sans gradient, etc., mais
Q: Les neurones Relu sont-ils généralement meilleurs que les neurones sigmoïdes / softmax? Faut-il presque toujours utiliser les neurones Relu dans NN (ou même CNN)? Je pensais qu'un neurone plus complexe introduirait de meilleurs résultats, du moins la précision du train si nous nous inquiétons du sur-ajustement.
Merci PS: Le code provient essentiellement de "Udacity-Machine learning -assignment2", qui est la reconnaissance de notMNIST à l'aide d'un simple NN à 1 couche cachée.
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)
la source
Réponses:
En plus de @Bhagyesh_Vikani:
Il existe également des généralisations d'unités linéaires rectifiées. Les unités linéaires rectifiées et ses généralisations sont basées sur le principe que les modèles linéaires sont plus faciles à optimiser.
Les deux sigmoid / softmax sont déconseillés (chapitre 6: Ian Goodfellow) pour la mise en œuvre de la rétroaction à la vanille. Ils sont plus utiles pour les réseaux récurrents, les modèles probabilistes et certains auto-encodeurs ont des exigences supplémentaires qui excluent l'utilisation de fonctions d'activation linéaires par morceaux.
Si vous avez un NN simple (c'est la question), Relu est votre première préférence .
la source
Relu a ses avantages et ses inconvénients:
Avantages:
1. Ne sature pas (dans la région + ve)
2. Calcul, il est très efficace
3. Généralement, les modèles avec des neurones relu convergent beaucoup plus rapidement que les neurones avec d'autres fonctions d'activation, comme décrit ici
Inconvénients:
1. Un problème avec eux est de savoir où ils meurent, c.-à-d. Relus mort. Parce que si l'activation de n'importe quel neurone relu devient nulle, ses gradients seront coupés à zéro en rétropropagation. Cela peut être évité si nous sommes très prudents avec l'initialisation des poids et le réglage du taux d'apprentissage.
Pour plus de détails: consultez cette conférence-5 de CS231n
la source
http://cs231n.github.io/neural-networks-1/
Sigmoids
Les sigmoides saturent et tuent les dégradés. Les sorties sigmoïdes ne sont pas centrées sur zéro.
tanh
Comme le neurone sigmoïde, ses activations saturent, mais contrairement au neurone sigmoïde, sa sortie est centrée sur zéro. Par conséquent, dans la pratique, la non-linéarité tanh est toujours préférée à la non-linéarité sigmoïde.
ReLU
Utilisez la non-linéarité ReLU, soyez prudent avec vos taux d'apprentissage et surveillez éventuellement la fraction d'unités «mortes» dans un réseau. Si cela vous concerne, essayez Leaky ReLU ou Maxout. N'utilisez jamais de sigmoïde. Essayez tanh, mais attendez-vous à ce qu'il fonctionne moins bien que ReLU / Maxout.
la source