Les pour rectifier linéaire de l'unité d'activation avec la croix de l'entropie d'erreur

Je suis en train de mettre en œuvre gradient de calcul pour les réseaux de neurones à l'aide de les.
Je ne peux pas le faire fonctionner avec la croix de l'entropie de l'erreur et la rectification unité linéaire (ReLU) activation.

J'ai réussi à obtenir mon travail de mise en œuvre de l'erreur quadratique avec sigmoïde, tanh et ReLU fonctions d'activation. La croix de l'entropie (CE) erreur d'activation sigmoïde gradient est calculé correctement. Cependant, lorsque je change l'activation ReLU - il échoue. (Je suis à sauter tanh pour CE qu'il retuls valeurs dans (-1,1) la portée.)

Est à cause du comportement de la fonction log à des valeurs proches de 0 (ce qui est retourné par ReLUs env. 50% du temps pour normalisé entrées)?
J'ai essayé de mitiage ce problème avec:

log(max(y,eps))

mais il ne m'a aidé à apporter de l'erreur et des gradients de retour de nombres réels - ils sont encore différents de numérique dégradé.

J'ai vérifier les résultats à l'aide numérique dégradé:

num_grad = (f(W+epsilon) - f(W-epsilon)) / (2*epsilon)

Le code matlab suivant présente une procédure simplifiée et condensée les mise en œuvre utilisé dans mes expériences:

function [f, df] = backprop(W, X, Y)
% W - weights
% X - input values
% Y - target values
act_type='relu';    % possible values: sigmoid /tanh /relu
error_type = 'CE';  % possible values: SE /CE
N=size(X,1); n_inp=size(X,2); n_hid=100; n_out=size(Y,2);
w1=reshape(W(1:n_hid*(n_inp+1)),n_hid,n_inp+1);
w2=reshape(W(n_hid*(n_inp+1)+1:end),n_out, n_hid+1);
% feedforward
X=[X ones(N,1)];
z2=X*w1'; a2=act(z2,act_type); a2=[a2 ones(N,1)];
z3=a2*w2'; y=act(z3,act_type);
if strcmp(error_type, 'CE')   % cross entropy error - logistic cost function
f=-sum(sum( Y.*log(max(y,eps))+(1-Y).*log(max(1-y,eps)) ));
else % squared error
f=0.5*sum(sum((y-Y).^2));
end
% backprop
if strcmp(error_type, 'CE')   % cross entropy error
d3=y-Y;
else % squared error
d3=(y-Y).*dact(z3,act_type);
end
df2=d3'*a2;
d2=d3*w2(:,1:end-1).*dact(z2,act_type);
df1=d2'*X;
df=[df1(:);df2(:)];
end
function f=act(z,type) % activation function
switch type
case 'sigmoid'
f=1./(1+exp(-z));
case 'tanh'
f=tanh(z);
case 'relu'
f=max(0,z);
end
end
function df=dact(z,type) % derivative of activation function
switch type
case 'sigmoid'
df=act(z,type).*(1-act(z,type));
case 'tanh'
df=1-act(z,type).^2;
case 'relu'
df=double(z>0);
end
end

---

Modifier

Après une autre série d'expériences, j'ai trouvé que l'utilisation d'un softmax pour la dernière couche:

y=bsxfun(@rdivide, exp(z3), sum(exp(z3),2));

et softmax fonction de coût:

f=-sum(sum(Y.*log(y)));

faire la implementaion de travail pour toutes les fonctions d'activation, y compris ReLU.

Ce qui m'amène à la conclusion que c'est la logistique de la fonction de coût (binaire clasifier) qui ne fonctionne pas avec ReLU:

f=-sum(sum( Y.*log(max(y,eps))+(1-Y).*log(max(1-y,eps)) ));

Cependant, je n'arrive toujours pas à comprendre où se situe le problème.