Gradient Descent Implementierung in der Oktave

Question

Ich habe eigentlich schon seit 2 Monaten dagegen kämpfen. Was macht diese anders?

hypotheses= X * theta 
temp=(hypotheses-y)' 
temp=X(:,1) * temp 
temp=temp * (1/m) 
temp=temp * alpha 
theta(1)=theta(1)-temp 

hypotheses= X * theta 
temp=(hypotheses-y)' 
temp=temp * (1/m) 
temp=temp * alpha 
theta(2)=theta(2)-temp 



theta(1) = theta(1) - alpha * (1/m) * ((X * theta) - y)' * X(:, 1); 
theta(2) = theta(2) - alpha * (1/m) * ((X * theta) - y)' * X(:, 2); 

Letzteres funktioniert. Ich bin nur nicht sicher, warum ... Ich habe Mühe, die Notwendigkeit für die Matrix inverse zu verstehen.

Answer 1

tun müssen, was Sie im ersten Beispiel in dem zweiten Block tun Sie einen Schritt verpasst haben haben Sie nicht? Ich nehme an, dass Sie X mit einem Vektor von Einsen verkettet haben.

temp=X(:,2) * temp 

Das letzte Beispiel wird funktionieren, kann aber noch mehr vektorisiert werden, um einfacher und effizienter zu sein.

Ich habe angenommen, Sie haben nur 1 Funktion. Es wird das gleiche mit mehreren Funktionen funktionieren, da Sie nur eine zusätzliche Spalte zu Ihrer X-Matrix für jede Funktion hinzufügen. Im Grunde fügst du einen Vektor von Einsen zu x hinzu, um den Achsenabschnitt zu vektorisieren.

Sie können eine 2x1 Matrix von Theta in einer Codezeile aktualisieren. Mit x verketten Sie einen Vektor von Einsen, die ihn zu einer nx2-Matrix machen, dann können Sie h (x) berechnen, indem Sie mit dem Theta-Vektor (2x1) multiplizieren, das ist (X * Theta) -Bit.

Der zweite Teil der Vektorisierung ist (X * theta) transponieren - y), die man eine 1 * N Matrix gibt, die, wenn multipliziert mit X (wird eine n * 2-Matrix) aggregieren grundsätzlich sowohl (h (x) -y) x0 und (h (x) -y) x1. Per Definition sind beide Thetas gleichzeitig erledigt. Dies führt zu einer 1 * 2-Matrix meiner neuen Thetas, die ich einfach erneut transponiere, um den Vektor umzuschalten, um dieselben Dimensionen wie der Theta-Vektor zu haben. Ich kann dann eine einfache Skalarmultiplikation durch Alpha- und Vektorsubtraktion mit Theta durchführen.

X = data(:, 1); y = data(:, 2); 
m = length(y); 
X = [ones(m, 1), data(:,1)]; 
theta = zeros(2, 1);   

iterations = 2000; 
alpha = 0.001; 

for iter = 1:iterations 
    theta = theta -((1/m) * ((X * theta) - y)' * X)' * alpha; 
end 

Answer 2

In der ersten, wenn X eine 3x2-Matrix wäre und Theta eine 2x1-Matrix wären, wären "Hypothesen" eine 3x1-Matrix.

Angenommen, y ist eine 3x1 Matrix, dann können Sie (Hypothesen - y) durchführen und eine 3x1 Matrix erhalten, dann ist die Transponierte dieser 3x1 eine 1x3 Matrix, die temp zugewiesen ist.

Dann wird die 1x3-Matrix auf Theta (2) gesetzt, aber dies sollte keine Matrix sein.

Die letzten beiden Zeilen des Codes funktioniert, weil meine mxn Beispiele oben mit,

(X * theta) 

wäre eine 3x1 Matrix.

Dann wird diese 3x1 Matrix von y subtrahiert (eine 3x1 Matrix) und das Ergebnis ist eine 3x1 Matrix.

Die Transponierte der 3x1-Matrix ist also eine 1x3-Matrix.

((X * theta) - y)' 

schließlich eine 1x3 Matrix mal eine 3x1-Matrix wird eine skalare oder 1x1 Matrix gleich, das ist das, was Sie suchen. Ich bin mir sicher, dass du es bereits wusstest, aber um genau zu sein, ist das X (:, 2) die zweite Spalte der 3x2-Matrix, was es zu einer 3x1-Matrix macht.

Answer 3

Wenn Sie aktualisieren Sie wie

Start Loop { 

temp0 = theta0 - (equation_here); 

temp1 = theta1 - (equation_here); 


theta0 = temp0; 

theta1 = temp1; 

} End loop 

Answer 4

. 
. 
. 
. 
. 
. 
. 
. 
. 
Spoiler alert 












m = length(y); % number of training examples 
J_history = zeros(num_iters, 1); 

for iter = 1:num_iters 

% ====================== YOUR CODE HERE ====================== 
% Instructions: Perform a single gradient step on the parameter vector 
%    theta. 
% 
% Hint: While debugging, it can be useful to print out the values 
%  of the cost function (computeCost) and gradient here. 
% ========================== BEGIN =========================== 


t = zeros(2,1); 
J = computeCost(X, y, theta); 
t = theta - ((alpha*((theta'*X') - y'))*X/m)'; 
theta = t; 
J1 = computeCost(X, y, theta); 

if(J1>J), 
    break,fprintf('Wrong alpha'); 
else if(J1==J) 
    break; 
end; 


% ========================== END ============================== 

% Save the cost J in every iteration  
J_history(iter) = sum(computeCost(X, y, theta)); 
end 
end 

Answer 5

function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters) 
% Performs gradient descent to learn theta. Updates theta by taking num_iters 
% gradient steps with learning rate alpha. 

% Number of training examples 
m = length(y); 
% Save the cost J in every iteration in order to plot J vs. num_iters and check for convergence 
J_history = zeros(num_iters, 1); 

for iter = 1:num_iters 
    h = X * theta; 
    stderr = h - y; 
    theta = theta - (alpha/m) * (stderr' * X)'; 
    J_history(iter) = computeCost(X, y, theta); 
end 

end