Réseau de neurones les avec RELU

Si vous avez une couche faite d'un seul ReLU, comme votre architecture suggère, alors oui, vous tuez le gradient 0. Pendant l'entraînement, la ReLU reviendra 0 à votre couche de sortie, qui retournera 0 ou 0.5 si vous utilisez des unités logistiques, et le softmax les écrasera. Donc une valeur de 0 sous votre architecture actuelle n'a pas beaucoup de sens pour la propagation de la partie.

Voir par exemple . Quel vous pouvez faire est d'utiliser un "leaky ReLU", qui est une petite valeur à 0, comme 0.01.

Je reconsidérerais cette architecture cependant, cela n'a pas beaucoup de sens pour moi de nourrir une seule ReLU dans un tas d'autres unités puis d'appliquer un softmax.

si x <= 0, la sortie est 0. si x > 0, la sortie est 1

la fonction ReLU est définie comme: pour x > 0 la sortie est x, i.e. f (x) = max(0,x)

donc pour le dérivé f '(x) c'est en fait:

si x < 0, la sortie est 0. si x > 0, la sortie est à 1.

La dérivée f '(0) n'est pas défini. Donc, il est généralement mis à 0 ou vous modifiez la fonction d'activation pour être f(x) = max (e,x) pour un petit E.

Généralement: A ReLU est une unité qui utilise la fonction d'activation du redresseur. Cela signifie qu'il fonctionne exactement comme n'importe quelle autre couche cachée, mais à l'exception de tanh(x), sigmoid(x) ou de n'importe quelle activation que vous utilisez,vous utiliserez à la place f(x) = max(0, x).

si vous avez écrit du code pour un réseau multicouche fonctionnel avec l'activation sigmoïde, c'est littéralement une ligne de changement. Rien au sujet de la propagation vers l'avant ou vers l'arrière ne change algorithmiquement. Si le modèle le plus simple ne fonctionne pas encore, retournez en arrière et commencez avec ça. premier. Dans le cas contraire, votre question ne porte pas vraiment sur la relance, mais sur la mise en œuvre d'une NN dans son ensemble.

voici un bon exemple, utilisez ReLU pour implémenter XOR: de référence, http://pytorch.org/tutorials/beginner/pytorch_with_examples.html

# -*- coding: utf-8 -*-
import numpy as np
import matplotlib.pyplot as plt

# N is batch size(sample size); D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 4, 2, 30, 1

# Create random input and output data
x = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# Randomly initialize weights
w1 = np.random.randn(D_in, H)
w2 = np.random.randn(H, D_out)

learning_rate = 0.002
loss_col = []
for t in range(200):
    # Forward pass: compute predicted y
    h = x.dot(w1)
    h_relu = np.maximum(h, 0)  # using ReLU as activate function
    y_pred = h_relu.dot(w2)

    # Compute and print loss
    loss = np.square(y_pred - y).sum() # loss function
    loss_col.append(loss)
    print(t, loss, y_pred)

    # Backprop to compute gradients of w1 and w2 with respect to loss
    grad_y_pred = 2.0 * (y_pred - y) # the last layer's error
    grad_w2 = h_relu.T.dot(grad_y_pred)
    grad_h_relu = grad_y_pred.dot(w2.T) # the second laye's error 
    grad_h = grad_h_relu.copy()
    grad_h[h < 0] = 0  # the derivate of ReLU
    grad_w1 = x.T.dot(grad_h)

    # Update weights
    w1 -= learning_rate * grad_w1
    w2 -= learning_rate * grad_w2

plt.plot(loss_col)
plt.show()

pour en savoir plus sur le dérivé de ReLU, vous pouvez voir ici:http://kawahara.ca/what-is-the-derivative-of-relu/

Oui la fonction de Relu originale a le problème que vous décrivez. Donc ils ont plus tard fait un changement à la formule, et l'ont appelé leaky Relu Essentiellement, Leaky Relu incline légèrement la partie horizontale de la fonction. pour plus d'informations, regardez ceci :

Une explication des méthodes d'activation, et une amélioration de la Relu sur youtube

en outre, ici vous pouvez trouver une implémentation dans le cadre de caffe:https://github.com/BVLC/caffe/blob/master/src/caffe/layers/relu_layer.cpp

la pente negative_slope spécifie s'il faut "faire fuiter" la partie négative en la multipliant par la valeur de la pente plutôt que de la fixer à 0. Bien sûr, vous devez mettre ce paramètre à zéro pour avoir la version classique.