matlab - नसभ - मध्य प्रदेश चुनाव परिणाम




रसद प्रतिगमन में लागत समारोह नतीजे के रूप में देता है (2)

आपके साथ ऐसा क्यों हो रहा हो सकता है दो संभावित कारण हैं

डेटा सामान्यीकृत नहीं है

इसका कारण यह है कि जब आप अपनी अवधारणा में सिग्मोयॉइड / लॉगिट फ़ंक्शन को लागू करते हैं, तो आउटपुट संभावनाएं लगभग सभी लगभग 0 या सभी 1 एस हैं और आपकी कॉस्ट फ़ंक्शन, log(1 - 1) या log(0) -Inf आपके कॉस्ट फ़ंक्शन में इन सभी व्यक्तिगत शर्तों का संचय अंततः NaN हो जाएगा

विशेष रूप से, यदि प्रशिक्षण उदाहरण के लिए y = 0 और यदि आपकी परिकल्पना का उत्पादन log(x) जहां x बहुत छोटी संख्या है जो कि करीब 0 है, तो लागत के पहले भाग की जांच करने से हमें 0*log(x) और वास्तव में NaN उत्पादन करेगा। इसी तरह, यदि प्रशिक्षण के उदाहरण के लिए y = 1 और यदि आपकी परिकल्पना का उत्पादन भी log(x) जहां x बहुत छोटी संख्या है, तो यह हमें फिर से 0*log(x) देगा और NaN उत्पादन करेगा। सीधे शब्दों में कहें, आपकी परिकल्पना का उत्पादन या तो बहुत करीब है 0 या बहुत करीब 1

यह इस तथ्य की वजह से सबसे अधिक संभावना है कि प्रत्येक फीचर की गतिशील रेंज व्यापक रूप से अलग है और इसलिए आपकी परिकल्पना का एक हिस्सा, विशेष रूप से प्रत्येक प्रशिक्षण उदाहरण के लिए x*theta का भारित योग, उदाहरण के लिए आपको या तो बहुत बड़ा नकारात्मक या सकारात्मक मूल्य प्रदान करेगा , और यदि आप इन मूल्यों में सिग्मॉइड फ़ंक्शन को लागू करते हैं, तो आप 0 या 1 के बहुत करीब आ सकते हैं।

इस से निपटने का एक तरीका ढालगत वंश का उपयोग कर प्रशिक्षण करने से पहले अपने मैट्रिक्स के डेटा को सामान्य करना है। एक सामान्य दृष्टिकोण शून्य-माध्य और यूनिट विचरण के साथ सामान्य होना है। एक इनपुट सुविधा को देखते हुए x_k जहां k = 1, 2, ... n जहां आपके पास n विशेषताएं हैं, नई सामान्यीकृत सुविधा x_k^{new} द्वारा पाई जा सकती है:

m_k सुविधा k और s_k का मतलब है कि सुविधा के मानक विचलन है k इसे डेटा मानकीकरण के रूप में भी जाना जाता है आप इस बारे में और अधिक जानकारी के बारे में यहां दिए गए अन्य उत्तर पर पढ़ सकते हैं: डेटा को मानकीकृत करने के लिए यह कोड कैसे काम करता है?

क्योंकि आप रेखीय बीजगणित दृष्टिकोण ढाल वंश के लिए उपयोग कर रहे हैं, मैं मानता हूं कि आपने अपने डेटा मैट्रिक्स को सभी लोगों के एक कॉलम के साथ तैयार किया है। यह जानकर, हम आपके डेटा को सामान्य मान सकते हैं:

mX = mean(x,1); 
mX(1) = 0; 
sX = std(x,[],1); 
sX(1) = 1; 
xnew = bsxfun(@rdivide, bsxfun(@minus, x, mX), sX);

प्रत्येक फीचर के मतलब और मानक विचलन क्रमशः mX और sX में जमा किए sX हैं। आप यह सीख सकते हैं कि यह कोड आपके द्वारा ऊपर लिखी हुई पोस्ट को पढ़कर कैसे काम करता है। मैं उस सामान को दोबारा नहीं दोहराऊंगा क्योंकि यह इस पोस्ट का दायरा नहीं है। उचित सामान्यीकरण सुनिश्चित करने के लिए, मैंने क्रमशः 0 और 1 के पहले स्तंभ का मतलब और मानक विचलन बनाया है। xnew में नया सामान्यीकृत डेटा मैट्रिक्स होता है इसके बजाय अपने ढाल वंश एल्गोरिदम के साथ xnew उपयोग करें। अब एक बार जब आप मापदंडों को ढूंढते हैं, तो किसी भी पूर्वानुमान को पूरा करने के लिए आपको प्रशिक्षण सेट से औसत और मानक विचलन के साथ किसी भी नए परीक्षण के उदाहरणों को सामान्य बनाना होगा । क्योंकि प्रशिक्षित पैरामीटर प्रशिक्षण सेट के आँकड़ों के संबंध में हैं, इसलिए आपको भविष्य के मॉडल के किसी भी टेस्ट डेटा को प्रस्तुत करने के लिए उसी परिवर्तनों को लागू करना होगा।

यह मानते हुए कि आपके पास नया डेटा अंक मैट्रिक्स में रखा गया है जिसे xx कहा जाता है, तो आप भविष्यवाणियों को सामान्य करने के लिए सामान्य करते हैं:

xxnew = bsxfun(@rdivide, bsxfun(@minus, xx, mX), sX);

अब जब आपके पास यह है, तो आप अपनी भविष्यवाणियां कर सकते हैं:

pred = sigmoid(xxnew*theta) >= 0.5;

आप 0.5 के थ्रेशोल्ड को बदल सकते हैं, जो आपको सबसे अच्छा लगता है कि जो कि सकारात्मक या नकारात्मक वर्ग के उदाहरण हैं।

सीखने की दर बहुत बड़ी है

जैसा कि आप टिप्पणियों में उल्लेख किया है, एक बार जब आप डेटा को सामान्य मानते हैं तो लागत सीमित होती है, लेकिन फिर कुछ पुनरावृत्तियों के बाद अचानक नाएन के पास जाते हैं। सामान्यकरण केवल आपको अभी तक प्राप्त कर सकता है यदि आपकी लर्निंग रेट या alpha बहुत बड़ी है, तो प्रत्येक पुनरावृत्ति को दिशा में दिशा में कम से कम किया जाएगा और इस प्रकार प्रत्येक पुनरावृत्त पर लागत कम हो जाएगी या फिर जो भी हो रहा है, वह अलग हो जाएगा। आपके मामले में, लागत उस बिंदु पर प्रत्येक चलना में भिन्न हो रही है या बढ़ रही है जहां यह इतनी बड़ी है कि इसे फ़्लोटिंग बिंदु सटीक का उपयोग करके प्रतिनिधित्व नहीं किया जा सकता है

जैसे, एक अन्य विकल्प यह है कि आप अपने सीखने की दर alpha को कम कर दें, जब तक आप यह नहीं देखते कि लागत समारोह प्रत्येक पुनरावृत्ति में घट रहा है। यह निर्धारित करने के लिए एक लोकप्रिय तरीका है कि सबसे अच्छा सीखने की दर alpha के लॉरेरिथमिक रूप से दूरी वाले मानों पर ढाल की उत्पत्ति को करने और अंतिम लागत का मूल्य क्या है और सीखने की दर को चुनने के लिए सबसे कम लागत का चयन करना है।

एक साथ दो तथ्यों का उपयोग करके ढाल के वंश को काफी अच्छी तरह से मिलना चाहिए, यह मानते हुए कि लागत कार्य उत्तल है। रसद प्रतिगमन के लिए इस मामले में, यह निश्चित रूप से है

मैं बैच ग्रेडिएंट वंश का उपयोग कर रसद प्रतिगमन को लागू कर रहा हूं। इसमें दो वर्ग हैं जिनमे इनपुट नमूनों को वर्गीकृत किया जाना है। वर्ग 1 और 0 हैं। डेटा को प्रशिक्षण देते समय, मैं निम्नलिखित सिग्मोअइड फ़ंक्शन का उपयोग कर रहा हूं:

t = 1 ./ (1 + exp(-z));

कहा पे

z = x*theta

और मैं ट्रेनिंग कब बंद करूँ, यह तय करने के लिए लागत का आकलन करने के लिए मैं निम्नलिखित लागत का उपयोग कर रहा हूं।

htheta = sigmoid(x*theta);
cost = sum(-y .* log(htheta) - (1-y) .* log(1-htheta));

मैं प्रत्येक कदम पर htheta होने के लिए लागत पा रहा हूं क्योंकि ज्यादातर मामलों में htheta के मूल्य 1 या शून्य हैं। हर चलन पर लागत मूल्य निर्धारित करने के लिए मुझे क्या करना चाहिए?

यह रसद प्रतिगमन के लिए ढाल वंश कोड है:

function [theta,cost_history] = batchGD(x,y,theta,alpha)

cost_history = zeros(1000,1);

for iter=1:1000
  htheta = sigmoid(x*theta);
  new_theta = zeros(size(theta,1),1);
  for feature=1:size(theta,1)
    new_theta(feature) = theta(feature) - alpha * sum((htheta - y) .*x(:,feature))                         
  end
  theta = new_theta;
  cost_history(iter) = computeCost(x,y,theta);
end
end

मान लीजिए कि आपके पास एक अवलोकन है जहां:

  • सही मान y_i = 1 है
  • आपका मॉडल काफी चरम है और कहता है कि पी (y_i = 1) = 1

तब आपके कॉस्ट फ़ंक्शन को NaN मान मिलेगा क्योंकि आप 0 * log(0) जोड़ रहे हैं, जो कि अपरिभाषित है। अत:

लागत कार्य के लिए आपका सूत्र एक समस्या है (एक सूक्ष्म 0, अनन्तता मुद्दा है)!

जैसा कि @ रेयरेंग ने बताया, 0 * log(0) एक नाएन का उत्पादन करता है क्योंकि 0 * Inf कोषेर नहीं है यह वास्तव में एक बड़ी समस्या है: यदि आपका एल्गोरिथ्म मानता है कि वह पूरी तरह से एक मूल्य की भविष्यवाणी कर सकता है, तो वह गलत रूप से NaN लागत असाइन करता है

के बजाय:

cost = sum(-y .* log(htheta) - (1-y) .* log(1-htheta));

आप अनंत के द्वारा 0 से गुणा करके अपने लागत कार्य को मटैब में लिखकर से बच सकते हैं:

y_logical = y == 1;
cost = sum(-log(htheta(y_logical))) + sum( - log(1 - htheta(~y_logical)));

यह विचार यह है कि अगर y_i 1 है, तो हम लागत को- -log(htheta_i) जोड़ते हैं, लेकिन अगर y_i 0 है, तो हम लागत -log(1 - htheta_i) को -log(1 - htheta_i) यह गणितीय रूप से -y_i * log(htheta_i) - (1 - y_i) * log(1- htheta_i) लेकिन संख्यात्मक समस्याएं नहीं htheta_i है, जो अनिवार्य रूप से htheta_i से htheta_i होकर 0 या 1 के बराबर होती है, जो कि डबल सटीक फ़्लोटिंग बिंदु ।