2011-10-16 15 views
8

अभिसरण नहीं करेगा मैं स्टैनफोर्ड मशीन लर्निंग लेक्चर (lecture 2 at around 25:00) में समझाया गया ग्रेडियेंट वंश एल्गोरिदम के लिए थोड़ा सा कोड लिखने की कोशिश कर रहा हूं। नीचे मैंने पहले उपयोग किया गया कार्यान्वयन है, और मुझे लगता है कि यह व्याख्यान से ठीक से कॉपी किया गया है, लेकिन जब मैं बड़ी संख्या में (>8) प्रशिक्षण सेट में जोड़ता हूं तो यह अभिसरण नहीं होता है।ग्रेडियेंट डेसेंट एल्गोरिदम

मैं एक नंबर X inputting रहा हूँ, और point (X,X), प्रशिक्षण सेट में जोड़ा जाता है तो इस समय, मैं केवल यह करने के लिए y=ax+b जहां a=1=theta\[1\] और b=0=theta\[0\] अभिसरण को पाने के लिए कोशिश कर रहा हूँ। प्रशिक्षण सेट सरणी x और y है, जहां (x[i],y[i]) एक बिंदु है।

void train() 
{ 
    double delta; 
    for (int i = 0; i < x.size(); i++) 
    { 
     delta = y[i]-hypothesis(x[i]); 
     theta[1] += alpha*delta*x[i]; 
     theta[0] += alpha*delta*1; 
    } 
} 

void C_Approx::display() 
{ 
    std::cout<<theta[1]<<"x + "<<theta[0]<<" \t "<<"f(x)="<<hypothesis(1)<<std::endl; 
} 
परिणाम मैं हो रही है में से कुछ

:

: मैं इनपुट एक नंबर है, यह train() कई बार, फिर display()

1 
0.33616x + 0.33616 f(x)=0.67232 
1 
0.482408x + 0.482408  f(x)=0.964816 
1 
0.499381x + 0.499381  f(x)=0.998762 
1 
0.499993x + 0.499993  f(x)=0.999986 
1 
0.5x + 0.5 f(x)=1 

यह अपसारी के बाद यह 8 पारित कर दिया का एक उदाहरण चलाता है

1 
0.33616x + 0.33616 f(x)=0.67232 
2 
0.705508x + 0.509914  f(x)=1.21542 
3 
0.850024x + 0.449928  f(x)=1.29995 
4 
0.936062x + 0.330346  f(x)=1.26641 
5 
0.951346x + 0.231295  f(x)=1.18264 
6 
0.992876x + 0.137739  f(x)=1.13062 
7 
0.932206x + 0.127372  f(x)=1.05958 
8 
1.00077x + 0.000493063 f(x)=1.00126 
9 
-0.689325x + -0.0714712  f(x)=-0.760797 
10 
4.10321e+08x + 4.365e+07  f(x)=4.53971e+08 
11 
1.79968e+22x + 1.61125e+21 f(x)=1.9608e+22 
12 
-3.9452e+41x + -3.26957e+40  f(x)=-4.27216e+41 

मैंने चरण को स्केल करने के लिए here प्रस्तावित समाधान की कोशिश की और इसी तरह के परिणामों के साथ समाप्त हो गया। मैं क्या गलत कर रहा हूँ?

उत्तर

9

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

+0

आप यादृच्छिक नमूना के आधार पर α कैसे निर्धारित करेंगे? – howardh

+0

@ हावर्ड, बस अलग-अलग मूल्यों की कोशिश करके और एक को चुनकर जो जल्दी से एक छोटे जे (θ) में परिवर्तित हो जाता है। –

+0

तो मैं केवल मूल प्रशिक्षण सेट, कॉल ट्रेन() से उस सेट के साथ यादृच्छिक रूप से चयनित डेटा बिंदुओं का एक नया सेट बना देता हूं, और यदि प्रत्येक चरण में त्रुटि कम नहीं होती है, तो मैं α कम करता हूं और दोहराता हूं? – howardh

0

यदि मैं आपको सही ढंग से समझता हूं, तो आपके प्रशिक्षण सेट में केवल एक पंक्ति के किनारे पर एक गैर-शून्य ढाल है? जब तक आप लाइन पर शुरू नहीं करते हैं (वास्तव में वास्तव में अपने प्रशिक्षण बिंदुओं में से एक पर शुरू होते हैं) आपको लाइन नहीं मिलेगी। आप हमेशा एक स्थानीय न्यूनतम पर रहते हैं।

1

जब आपकी लागत कार्य बढ़ जाती है या चक्र ऊपर और नीचे होते हैं, तो आमतौर पर alpha के लिए आपके पास बहुत अधिक मूल्य होता है। क्या आप alpha उपयोग कर रहे हैं?

alpha = 0.001 के साथ शुरू करें और देखें कि क्या यह अभिसरण है? यदि विभिन्न alphas(0.003, 0.01, 0.03, 0.1, 0.3, 1) आज़माएं और जल्दी से एकत्र होने वाले किसी को ढूंढें।

डेटा (सामान्य) स्केलिंग केवल 1 सुविधा (अपने theta[1]) के रूप में सामान्य केवल 2+ सुविधाओं पर लागू होता है (मल्टीवेरिएट रेखीय प्रतीपगमन) के साथ आप मदद नहीं करेगा।

यह भी ध्यान रखें कि सुविधाओं की एक छोटी संख्या के लिए आप सही उत्तर प्राप्त करने के लिए सामान्य समीकरण का उपयोग कर सकते हैं।

3

मुझे एक ही समस्या का अनुभव हुआ है (जावा में यद्यपि) क्योंकि मेरी सीखने की दर बहुत बड़ी थी।
संक्षेप में, मैं α = 0.001 का उपयोग कर रहा था और मुझे वास्तविक अभिसरण देखने के लिए इसे 0.000001 पर धक्का देना पड़ा।

बेशक ये मान आपके डेटासेट से जुड़े हुए हैं।

0

अभिसरण अभिसरण के लिए बैकट्रैकिंग लाइन खोज का उपयोग करें। इसे लागू करना बहुत आसान है। संदर्भ के लिए स्टीफन बॉयड, उत्तल अनुकूलन देखें। आप बैकट्रैकिंग लाइन खोज के लिए कुछ मानक अल्फा, बीटा मान चुन सकते हैं, उदाहरण के लिए 0.3 और 0.8।

संबंधित मुद्दे