मैं निर्णय स्टंप का उपयोग करके Adaboost को लागू करना चाहता हूं। क्या Adaboost के प्रत्येक पुनरावृत्ति में हमारे डेटा सेट की सुविधाओं के रूप में कई निर्णय स्टंप करना सही है?
उदाहरण के लिए, यदि मेरे पास 24 विशेषताओं वाला डेटा सेट है, तो क्या मुझे प्रत्येक पुनरावृत्ति में 24 निर्णय स्टंप क्लासिफायर होना चाहिए? या क्या मुझे सभी विशेषताओं के बजाय कुछ सुविधाओं को अनियमित रूप से चुनना चाहिए और उन पर क्लासिफायर करना चाहिए?
जवाबों:
प्रशिक्षण का विशिष्ट तरीका (1-स्तरीय) डिसीजन ट्री ऐसी विशेषता ढूंढ रहा है जो शुद्धतम विभाजन देता है। यानी अगर हम अपने डेटासेट को दो सबसेट में विभाजित करते हैं, तो हम चाहते हैं कि इन सबसेट के अंदर लेबल यथासंभव समरूप हों। तो यह कई पेड़ों के निर्माण के रूप में भी देखा जा सकता है - प्रत्येक विशेषता के लिए एक पेड़ - और फिर सबसे अच्छा विभाजन पैदा करने वाले पेड़ का चयन करना।
कुछ मामलों में यह विशेषताओं का सबसेट का चयन करने के लिए भी समझ में आता है और फिर सबसेट पर पेड़ों को प्रशिक्षित करता है। उदाहरण के लिए, इसका उपयोग रैंडम फ़ॉरेस्ट में व्यक्तिगत पेड़ों के बीच संबंध को कम करने के लिए किया जाता है।
लेकिन जब यह AdaBoost की बात आती है, तो आमतौर पर यह सुनिश्चित करने के लिए पर्याप्त होता है कि बेस क्लासिफायर को तौले गए डेटा बिंदुओं पर प्रशिक्षित किया जा सकता है, और यादृच्छिक सुविधा का चयन कम महत्वपूर्ण है। निर्णय के पेड़ वज़न संभाल सकते हैं (उदाहरण के लिए यहां या यहां देखें )। यह कुल उप-अशुद्धता के लिए प्रत्येक डेटा बिंदु के योगदान को भारित करके किया जा सकता है।
संदर्भ के लिए मैं भी अपने AdaBoost कार्यान्वयन को अजगर केDecisionTreeClassifier साथ सुपी और स्केलेर्न के साथ जोड़ूंगाmax_depth=1 :
# input: dataset X and labels y (in {+1, -1})
hypotheses = []
hypothesis_weights = []
N, _ = X.shape
d = np.ones(N) / N
for t in range(num_iterations):
h = DecisionTreeClassifier(max_depth=1)
h.fit(X, y, sample_weight=d)
pred = h.predict(X)
eps = d.dot(pred != y)
alpha = (np.log(1 - eps) - np.log(eps)) / 2
d = d * np.exp(- alpha * y * pred)
d = d / d.sum()
hypotheses.append(h)
hypothesis_weights.append(alpha)लेबल की भविष्यवाणी के लिए:
# X input, y output
y = np.zeros(N)
for (h, alpha) in zip(hypotheses, hypotheses_weight):
y = y + alpha * h.predict(X)
y = np.sign(y)