ऑक्टेट

Question

में ग्रेडियेंट डेसेंट कार्यान्वयन वास्तव में मैं इसके खिलाफ 2 महीने की तरह संघर्ष कर रहा हूं। यह क्या है जो इन्हें अलग करता है?

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

उत्तरार्द्ध काम करता है। मुझे यकीन नहीं है कि क्यों .. मैं मैट्रिक्स उलटा की आवश्यकता को समझने के लिए संघर्ष करता हूं।

Answer 1

करने की जरूरत है आप नहीं है? मैं मानता हूं कि आप एक्स के एक वेक्टर के साथ एक्स को संयोजित कर रहे हैं।

temp=X(:,2) * temp 

अंतिम उदाहरण काम करेगा लेकिन अधिक सरल और कुशल होने के लिए और भी वेक्टरकृत किया जा सकता है।

मैंने माना है कि आपके पास केवल 1 सुविधा है। यह कई विशेषताओं के साथ भी काम करेगा क्योंकि ऐसा होता है कि आप प्रत्येक सुविधा के लिए अपने एक्स मैट्रिक्स में एक अतिरिक्त कॉलम जोड़ते हैं। मूल रूप से आप अवरोध को सदिश बनाने के लिए x में से एक वेक्टर जोड़ते हैं।

आप कोड की एक पंक्ति में thetas के 2x1 मैट्रिक्स को अपडेट कर सकते हैं। X के साथ इसे एक nx2 मैट्रिक्स बनाने वाले वेक्टर को संयोजित करें, फिर आप थेटा वेक्टर (2x1) द्वारा गुणा करके एच (एक्स) की गणना कर सकते हैं, यह (एक्स * थीटा) बिट है।

वेक्टरनाइज़ेशन का दूसरा भाग ट्रांसफर (एक्स * थेटा) - वाई) है जो आपको 1 * एन मैट्रिक्स देता है जो एक्स (एन * 2 मैट्रिक्स) द्वारा गुणा करके मूल रूप से दोनों (एच (एक्स) -y) x0 और (एच (एक्स) -y) x1। परिभाषा के अनुसार दोनों थैटा एक ही समय में किए जाते हैं। इसके परिणामस्वरूप मेरे नए थेटा के 1 * 2 मैट्रिक्स में मैं वेक्टर वेक्टर के समान आयाम होने के लिए वेक्टर के चारों ओर फ़्लिप करने के लिए फिर से स्थानांतरित करता हूं। मैं अल्फा और वेक्टर के साथ वेक्टर घटाव द्वारा एक सरल स्केलर गुणा कर सकता हूं।

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

पहले में, यदि एक्स 3x2 मैट्रिक्स थे और थेटा 2x1 मैट्रिक्स थे, तो "परिकल्पना" एक 3x1 मैट्रिक्स होगी।

मान लीजिए वाई 3x1 मैट्रिक्स है, तो आप प्रदर्शन कर सकते हैं (परिकल्पना - वाई) और 3x1 मैट्रिक्स प्राप्त करें, फिर उस 3x1 का स्थानांतरण 1x3 मैट्रिक्स temp को असाइन किया गया है।

फिर 1x3 मैट्रिक्स theta (2) पर सेट है, लेकिन यह एक मैट्रिक्स नहीं होना चाहिए।

अपने कोड के अंतिम दो पंक्तियों काम करता है, क्योंकि ऊपर मेरी MXN उदाहरण का उपयोग करते हुए,

(X * theta) 

एक 3x1 मैट्रिक्स होगा।

तब 3x1 मैट्रिक्स y (एक 3x1 मैट्रिक्स) द्वारा घटाया जाता है और परिणाम 3x1 मैट्रिक्स होता है।

(X * theta) - y 

तो 3x1 मैट्रिक्स का स्थानांतरण 1x3 मैट्रिक्स है।

((X * theta) - y)' 

अंत में, एक 1x3 मैट्रिक्स बार एक 3x1 मैट्रिक्स एक अदिश या 1x1 मैट्रिक्स, है जो क्या आप देख रहे हैं के बराबर होगा। मुझे यकीन है कि आप पहले से ही जानते थे, लेकिन बस पूरी तरह से होने के लिए, एक्स (:, 2) 3x2 मैट्रिक्स का दूसरा स्तंभ है, जो इसे 3x1 मैट्रिक्स बनाता है।

Answer 3

जब आप अद्यतन क्या आप दूसरे खंड आप एक कदम बाहर नहीं छूटा है में पहले उदाहरण में कर रहे हैं की तरह

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