Was mit meinem Gradientenabstiegsalgorithmus

Question

Hallo falsch Ich versuche Gradientenabstiegsalgorithmus für eine Funktion zu implementieren:

für den Algorithmus Mein Ausgangspunkt ist w = (u, v) = (2,2). Die Lernrate beträgt eta = 0,01 und gebunden = 10^-14. Hier ist meine MATLAB-Code:

function [resultTable, boundIter] = gradientDescent(w, iters, bound, eta) 
% FUNCTION [resultTable, boundIter] = gradientDescent(w, its, bound, eta) 
% 
% DESCRIPTION: 
% - This function will do gradient descent error minimization for the 
% function E(u,v) = (u*exp(v) - 2*v*exp(-u))^2. 
% 
% INPUTS: 
% 'w' a 1-by-2 vector indicating initial weights w = [u,v] 
% 'its' a positive integer indicating the number of gradient descent 
% iterations 
% 'bound' a real number indicating an error lower bound 
% 'eta' a positive real number indicating the learning rate of GD algorithm 
% 
% OUTPUTS: 
% 'resultTable' a iters+1-by-6 table indicating the error, partial 
% derivatives and weights for each GD iteration 
% 'boundIter' a positive integer specifying the GD iteration when the error 
% function got below the given error bound 'bound' 
% 


% The error function 
E = @(u,v) (u*exp(v) - 2*v*exp(-u))^2; 

% Partial derivative of E with respect to u 
pEpu = @(u,v) 2*(u*exp(v) - 2*v*exp(-u))*(exp(v) + 2*v*exp(-u)); 
% Partial derivative of E with respect to v 
pEpv = @(u,v) 2*(u*exp(v) - 2*v*exp(-u))*(u*exp(v) - 2*exp(-u)); 

% Initialize boundIter 
boundIter = 0; 
% Create a table for holding the results 
resultTable = zeros(iters+1, 6); 
% Iteration number 
resultTable(1, 1) = 0; 
% Error at iteration i 
resultTable(1, 2) = E(w(1), w(2)); 
% The value of pEpu at initial w = (u,v) 
resultTable(1, 3) = pEpu(w(1), w(2)); 
% The value of pEpv at initial w = (u,v) 
resultTable(1, 4) = pEpv(w(1), w(2)); 
% Initial u 
resultTable(1, 5) = w(1); 
% Initial v 
resultTable(1, 6) = w(2); 

% Loop all the iterations 
for i = 2:iters+1 

    % Save the iteration number 
    resultTable(i, 1) = i-1; 
    % Update the weights 
    temp1 = w(1) - eta*(pEpu(w(1), w(2))); 
    temp2 = w(2) - eta*(pEpv(w(1), w(2))); 
    w(1) = temp1; 
    w(2) = temp2; 
    % Evaluate the error function at new weights 
    resultTable(i, 2) = E(w(1), w(2)); 
    % Evaluate pEpu at the new point 
    resultTable(i, 3) = pEpu(w(1), w(2)); 
    % Evaluate pEpv at the new point 
    resultTable(i, 4) = pEpv(w(1), w(2)); 
    % Save the new weights 
    resultTable(i, 5) = w(1); 
    resultTable(i, 6) = w(2); 
    % If the error function is below a specified bound save this iteration 
    % index 
    if E(w(1), w(2)) < bound 
     boundIter = i-1; 
    end 

end 

Dies ist eine Übung in meiner Maschine Learning-Kurs, aber aus irgendeinem Grund meine Ergebnisse sind alle falsch. Im Code muss etwas nicht stimmen. Ich habe versucht, es zu debuggen und zu debuggen und habe nichts falsch gefunden ... kann jemand identifizieren, was mein Problem hier ist? ... Mit anderen Worten können Sie überprüfen, dass der Code gültiger Gradientabstiegalgorithmus für die gegebene Funktion ist?

Bitte lassen Sie mich wissen, wenn meine Frage zu unklar ist oder wenn Sie mehr Informationen benötigen :)

Vielen Dank für Ihre Mühe und helfen! =)

Hier ist meine Ergebnisse für fünf Wiederholungen und was andere Leute haben:

PARAMETER: w = [2,2], eta = 0,01 Grenze = 10^-14, iters = 5

Answer 1

Wie unter der Frage diskutiert: ich würde sagen, die andere sind falsch ... Ihre Minimierung zu kleineren Werten von E(u,v) führt, überprüfen:

(Ich entschuldige mich für nicht nur zu kommentieren, aber ich bin neu zu SO und nicht kommentieren.)

E(1.4,1.6) = 37.8 >> 3.6 = E(0.63, -1.67) 

Answer 2

Es scheint, dass Ihr Algorithmus das Richtige tut. Was Sie sicher sein wollen ist, dass bei jedem Schritt die Energie schrumpft (was es ist). Es gibt mehrere Gründe, warum Ihre Datenpunkte möglicherweise nicht mit den anderen in der Klasse übereinstimmen: Sie könnten falsch liegen (Sie oder andere in der Klasse), sie haben vielleicht an einem anderen Punkt begonnen, vielleicht haben sie eine andere Schrittgröße verwendet (was Sie sind) eta, ich glaube).

Im Idealfall möchten Sie die Anzahl der Iterationen nicht fest codieren. Sie möchten fortfahren, bis Sie ein lokales Minimum erreichen (das hoffentlich das globale Minimum ist). Um dies zu überprüfen, wollen Sie, dass beide partiellen Ableitungen Null (oder sehr nahe) sind. Um sicherzustellen, dass Sie sich in einem lokalen Min (nicht einem lokalen Max oder Sattelpunkt) befinden, sollten Sie das Zeichen E_uu * E_vv - E_uv^2 und das Zeichen von E_uu überprüfen: http://en.wikipedia.org/wiki/Second_partial_derivative_test für Details (das zweite Ableitungsversuch, oben). Wenn Sie sich an einem lokalen Max- oder Sattelpunkt befinden, wird Ihr Gradient Ihnen sagen, dass Sie sich nicht bewegen sollen (da die partiellen Ableitungen 0 sind). Da Sie wissen, dass dies nicht optimal ist, müssen Sie nur Ihre Lösung stören (manchmal auch simuliertes Glühen genannt).

Hoffe, das hilft.

Answer 3

keine vollständige Antwort, sondern lässt es gehen:

ich einen Plotten Teil in Ihrem Code hinzugefügt, damit Sie sehen können, was los ist.

u1=resultTable(:,5); 
v1=resultTable(:,6); 
E1=E(u1,v1); 
E1(E1<bound)=NaN; 
[x,y]=meshgrid(-1:0.1:5,-5:0.1:2);Z=E(x,y); 
surf(x,y,Z) 

hold on 
plot3(u1,v1,E1,'r') 
plot3(u1,v1,E1,'r*') 

Das Ergebnis zeigt, dass Ihr Algorithmus für diese Funktion das Richtige tut.Also, wie andere sagten, oder alle anderen sind falsch, oder Sie verwenden nicht die richtige Gleichung vom Anfang an.