Soru Oktavda Gradyan Descent uygulaması


Aslında 2 aydır buna karşı mücadele ediyorum. Bunları farklı kılan nedir?

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);

İkincisi çalışır. Neden emin değilim .. Matrisin tersine olan ihtiyacını anlamaya çalışıyorum.


32
2018-05-14 21:28


Menşei


Bunun, gradyan inişinin düzgün bir uygulaması olduğunu düşünmüyorum. Güncellemeniz gerekiyor. Her iki senin de aynı zamanda doğru. tmpTheta1= theta(1) - alpha * (1/m) * ((X * theta) - y)' * X(:, 1); tmpTheta2= theta(2) - alpha * (1/m) * ((X * theta) - y)' * X(:, 2);  theta(1)=tmpTheta1;  theta(2)=tmpTheta2; - Einar Sundgren


Cevaplar:


İlk blokta yaptığınız ilk örnekte ikinci blokta bir adım atmadınız değil mi? X'i bir vektörlerle birleştirdiğini varsayıyorum.

   temp=X(:,2) * temp

Son örnek işe yarayacak, ancak daha basit ve verimli olması için daha da fazla vektörleştirilebilir.

Sadece 1 özelliğiniz olduğunu varsaydım. Birden fazla özellikte aynı şekilde çalışacaktır, çünkü bu gerçekleşen her şey için X matrisinize fazladan bir sütun eklersiniz. Temelde, kesişmeyi vektörleştirmek için x'e olanlardan bir vektör eklersiniz.

Bir 2x1 matrisini bir satır kodda güncelleyebilirsiniz. X ile nx2 matrisini yapan bir vektörü birleştirerek, ota vektörü (2x1) ile çarparak h (x) 'i hesaplayabilirsiniz, bu (X * teta) bitidir.

Vektörleştirmenin ikinci kısmı, X ile çarpıldığında (bir n * 2 matrisi) temel olarak her ikisini (h (x) -y) x0 birleştirecek olan bir 1 * n matris veren (X * teta) - y) transpoze etmektir. ve (h (x) -y) x1. Tanım olarak her iki teta aynı zamanda yapılır. Bu, yeni theta'mın 1 * 2 matrisiyle sonuçlanır, ben sadece vektörün etrafında dönerek teta vektörü ile aynı boyutta olur. Ardından, teta ile alfa ve vektör çıkarma ile basit bir skaler çoğaltma yapabilirim.

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

56
2018-03-19 19:01



for döngüsünüzde neden (1 / m) * ((X * teta) - y) '* X aktarmanız gerekiyor? - Graham Slick
Grahm ile aynı soru, neden tüm alt ifadeler niçin gerçekleşti? - qbert65536
Sonucu ((1/m) * ((X * theta) - y)' * X) 1x2. theta 2x1. Dolayısıyla, parantezler arasındaki bitin aynı boyutlara sahip olması ve çıkarılması gerekir. theta. - AronVanAmmers
Yukarıdaki gibi aynı soru. Bu, theta = theta - (alfa / m) * X '* olmalıdır (X * teta - y) - Zerubbabel
Bunun matris hesaplama kuralları ile ilgili olduğunu düşünüyorum ... A * B = B satırlarının A satırlarının ürünü ... Yani, kavramsal olarak, gradyan için genel formülleri kullanmayı tamam, ancak Matris alanlarında oynamak, kendi kurallarına uyum sağlamanız gerekir (satırların satırlarla çarpılması, değişmez kısıtlamalar, vs.). Bu sadece benim tahminim, belki de yanılıyorum ... - Telmo


İlkinde, eğer X 3x2 matrisiyse ve teta 2x1 matrisiyse, o zaman “hipotezler” 3x1 matris olurdu.

Y 3x1 matris olduğunu varsayarak (hipotezler - y) ve 3x1 matrisini elde edersiniz, o zaman 3x1'in temposu temp'e atanan 1x3 matrisidir.

Sonra 1x3 matrisi teta (2) olarak ayarlandı, ama bu bir matris olmamalıdır.

Kodunuzun son iki satırı işe yarar çünkü yukarıdaki mxn örneklerini kullanıyorum.

(X * theta)

3x1 matris olur.

Sonra bu 3x1 matrisi y (3x1 matris) ile çıkarılır ve sonuç 3x1 matrisidir.

(X * theta) - y

Yani 3x1 matrisinin transpoz 1x3 matrisidir.

((X * theta) - y)'

Son olarak, bir 3x1 matrisinin 1x3 matris zamanları, aradığınız şey olan bir skaler veya 1x1 matrise eşit olacaktır. Eminim zaten biliyorsunuzdur, ama sadece eksiksiz olmak gerekirse, X (:, 2) 3x2 matrisinin ikinci sütunu olur ve 3x1 matris yapar.


5
2018-05-16 22:47





Güncellediğinizde yapmanız gereken

Start Loop {

temp0 = theta0 - (equation_here);

temp1 = theta1 - (equation_here);


theta0 =  temp0;

theta1 =  temp1;

} End loop

3
2017-10-22 19:21





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

0
2017-10-18 21:45





.
.
.
.
.
.
.
.
.
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

-8
2018-06-05 15:55



fikir, kullanıcıların ev alıştırmaları için tam örnek göndermemelerine yardımcı olmaktır. - EdvardM