Ich versuche, die Gradientenberechnung für neuronale Netze mit Backpropagation zu implementieren. Ich kann es nicht dazu bringen, mit einem Kreuzentropiefehler und einer gleichgerichteten Lineareinheit (ReLU) als Aktivierung zu arbeiten.

Ich habe es geschafft, meine Implementierung für Fehlerquadrate mit Sigmoid-, Tanh- und ReLU-Aktivierungsfunktionen zum Laufen zu bringen. Der Kreuzentropiefehler (CE-Fehler) mit dem Sigma-Aktivierungsgradienten wird korrekt berechnet. Wenn ich jedoch die Aktivierung auf ReLU ändere, schlägt dies fehl. (Ich überspringe Tanh für CE, da es Werte im (-1,1) -Bereich zurückhält.)

Liegt es am Verhalten der Protokollfunktion bei Werten nahe 0 (was von ReLUs ca. 50% der Zeit für normalisierte Eingaben zurückgegeben wird)? Ich habe versucht, dieses Problem zu lindern mit:

log(max(y,eps))

Aber es hat nur geholfen, Fehler und Verläufe auf reelle Zahlen zurückzuführen - sie unterscheiden sich immer noch von numerischen Verläufen.

Ich überprüfe die Ergebnisse mit einem numerischen Farbverlauf:

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

Der folgende Matlab-Code zeigt eine vereinfachte und komprimierte Backpropagation-Implementierung, die in meinen Experimenten verwendet wurde:

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

Bearbeiten

Nach einer weiteren Runde von Experimenten fand ich heraus, dass für die letzte Schicht ein Softmax verwendet wurde:

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

und Softmax-Kostenfunktion:

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

Stellen Sie sicher, dass die Implementierung für alle Aktivierungsfunktionen einschließlich ReLU funktioniert.

Dies lässt mich zu dem Schluss kommen, dass es die logistische Kostenfunktion (binärer Clasifier) ist, die mit ReLU nicht funktioniert:

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

Ich kann jedoch immer noch nicht herausfinden, wo das Problem liegt.