machine learning - ढाल वंश असफल लगता है




machine-learning octave (6)

इस तरह से इसके क्लीनर, और वेक्टरकृत भी

predictions = X * theta;
errorsVector = predictions - y;
theta = theta - (alpha/m) * (X' * errorsVector);

मैंने एक छवि को अच्छी गुणवत्ता के निर्धारण के लिए एक परिकल्पना प्राप्त करने के लिए एक लागत समारोह को कम करने के लिए एक ग्रेडियेंट वंश एल्गोरिदम लागू किया। मैंने ऑक्टेव में ऐसा किया। विचार किसी भी तरह एंड्रयू एनजी द्वारा मशीन लर्निंग क्लास से एल्गोरिदम पर आधारित है

इसलिए मेरे पास 880 मान "y" हैं जिनमें 0.5 से ~ 12 के मान शामिल हैं। और मेरे पास "एक्स" में 50 से 300 के 880 मान हैं जो छवि की गुणवत्ता की भविष्यवाणी कर सकते हैं।

अफसोस की बात है कि एल्गोरिदम विफल हो रहा है, कुछ पुनरावृत्तियों के बाद थेटा के लिए मूल्य इतना छोटा है, कि theta0 और theta1 "NaN" बन गया है। और मेरे रैखिक प्रतिगमन वक्र में अजीब मूल्य हैं ...

यहां ग्रेडियेंट वंश एल्गोरिदम के लिए कोड है: ( theta = zeros(2, 1); अल्फा = 0.01, पुनरावृत्तियों = 1500)

function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters)

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

for iter = 1:num_iters


    tmp_j1=0;
for i=1:m, 
    tmp_j1 = tmp_j1+ ((theta (1,1) + theta (2,1)*X(i,2)) - y(i));
end

    tmp_j2=0;
for i=1:m, 
    tmp_j2 = tmp_j2+ (((theta (1,1) + theta (2,1)*X(i,2)) - y(i)) *X(i,2)); 
end

    tmp1= theta(1,1) - (alpha *  ((1/m) * tmp_j1))  
    tmp2= theta(2,1) - (alpha *  ((1/m) * tmp_j2))  

    theta(1,1)=tmp1
    theta(2,1)=tmp2

    % ============================================================

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

और यहां लागत के लिए गणना है:

function J = computeCost(X, y, theta)   %

m = length(y); % number of training examples
J = 0;
tmp=0;
for i=1:m, 
    tmp = tmp+ (theta (1,1) + theta (2,1)*X(i,2) - y(i))^2; %differenzberechnung
end
J= (1/(2*m)) * tmp
end

एक वेक्टरीकृत संस्करण की तरह स्केलेबल नहीं होने पर, एक ढाल वाले वंश के लूप-आधारित गणना को एक ही परिणाम उत्पन्न करना चाहिए। उपर्युक्त उदाहरण में, सही थाटा की गणना करने में विफल होने वाले ढाल वंश का सबसे संभव मामला अल्फा का मान है।

लागत और ढाल वंश कार्यों के एक सत्यापित सेट और प्रश्न में वर्णित डेटा के साथ डेटा के एक सेट के साथ, alpha = 0.01 अगर कुछ पुनरावृत्तियों के बाद हीता NaN मानों के साथ समाप्त होता है। हालांकि, जब alpha = 0.000001 रूप में सेट किया जाता है, तो ग्रेडियेंट वंश 100 पुनरावृत्तियों के बाद भी अपेक्षित काम करता है।


मैंने थेटा चीज को सदिश दिया ... किसी की मदद कर सकता है

theta = theta - (alpha/m *  (X * theta-y)' * X)';

यदि आप कम से कम वर्ग लागत फ़ंक्शन का उपयोग करने के ठीक हैं, तो आप ढाल वंश के बजाय सामान्य समीकरण का उपयोग करने का प्रयास कर सकते हैं। यह बहुत आसान है - केवल एक पंक्ति - और कम्प्यूटेशनल रूप से तेज़।

यहां सामान्य समीकरण है: http://mathworld.wolfram.com/NormalEquation.html

और ऑक्टेटव रूप में:

theta = (pinv(X' * X )) * X' * y

यहां एक ट्यूटोरियल है जो बताता है कि सामान्य समीकरण का उपयोग कैसे करें: http://www.lauradhamilton.com/tutorial-linear-regression-with-octave


यह काम करना चाहिए: -

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

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

यहां केवल वैक्टर का उपयोग करना गणित में ग्रेडियेंट वंश के साथ एलआर का कॉम्पैक्ट कार्यान्वयन है:

Theta = {0, 0}
alpha = 0.0001;
iteration = 1500;
Jhist = Table[0, {i, iteration}];
Table[  
  Theta = Theta - 
  alpha * Dot[Transpose[X], (Dot[X, Theta] - Y)]/m; 
  Jhist[[k]] = 
  Total[ (Dot[X, Theta] - Y[[All]])^2]/(2*m); Theta, {k, iteration}]

नोट: बेशक कोई मानता है कि एक्स एक * 2 मैट्रिक्स है, एक्स [[, 1]] के साथ केवल 1 एस '