ग्रेडिएंट बूस्टेड डिसीजन ट्री

बैगिंग और बूस्टिंग की तरह, ग्रेडिएंट बूस्टिंग एक ऐसा तरीका है जो किसी दूसरे मशीन लर्निंग एल्गोरिदम के ऊपर लागू किया जाता है. अनौपचारिक रूप से, ग्रेडिएंट बूस्ट में दो तरह के मॉडल शामिल होते हैं:

  • एक मशीन लर्निंग मॉडल "weak" जो आम तौर पर फ़ैसला लेने वाला पेड़ होता है.
  • एक "strong" मशीन लर्निंग मॉडल, जो कई कमज़ोर मॉडल से बना है.

ग्रेडिएंट बूस्टिंग में, हर चरण पर एक नए कमज़ोर मॉडल को ट्रेनिंग दी जाती है, जो कि मौजूदा मज़बूत मॉडल के "गड़बड़ी"(इसे स्यूडो रिस्पॉन्स कहा जाता है) का अनुमान लगाता है. हम बाद में गड़बड़ी और कोट की जानकारी देंगे. फ़िलहाल, मान लीजिए कि "गड़बड़ी और कोट; अनुमान और रिग्रेशन लेबल के बीच का अंतर है. कमज़ोर मॉडल (जिसे "गड़बड़ी&कोट;) के बाद, मज़बूत मॉडल में गड़बड़ी के निशान से कम करके उसे मज़बूत मॉडल में जोड़ दिया जाता है.

ग्रेडिएंट बूस्टिंग फिर से होती है. हर बार इस फ़ॉर्मूला को लागू करना होता है:

\[ F_{i+1} = F_i - f_i \]

कहां:

  • $F_i$, चरण $i$ का मज़बूत मॉडल है.
  • $f_i$, $i$ चरण का कमज़ोर मॉडल है.

यह कार्रवाई तब तक दोहराई जाती है जब तक कि रोकने वाली शर्त को पूरा नहीं कर लिया जाता, जैसे कि बार-बार दोहराए जाने की संख्या या जब (मज़बूत) मॉडल किसी अलग पुष्टि डेटासेट में मापे गए तरीके से ज़्यादा फ़िट होने लगता हो.

आइए, आसान रिग्रेशन डेटासेट पर ग्रेडिएंट बूस्टिंग दिखाते हैं, जहां:

  • इसका मकसद $x$ से $y$ का अनुमान लगाना है.
  • मज़बूत मॉडल को ज़ीरो कॉन्सटेंट के तौर पर शुरू किया जाता है: $F_0(x) = 0$.
# Simplified example of regressive gradient boosting.

y = ... # the labels
x = ... # the features

strong_model = []
strong_predictions = np.zeros_like(y) # Initially, the strong model is empty.

for i in range(num_iters):

    # Error of the strong model
    error = strong_predictions - y

    # The weak model is a decision tree (see CART chapter)
    # without pruning and a maximum depth of 3.
    weak_model = tfdf.keras.CartModel(
        task=tfdf.keras.Task.REGRESSION,
        validation_ratio=0.0,
        max_depth=3)
    weak_model.fit(x=x, y=error)

    strong_model.append(weak_model)

    weak_predictions = weak_model.predict(x)[:,0]

    strong_predictions -= weak_predictions

इस कोड को इस डेटासेट पर लागू करें:

एक सुविधा, x, और इसके लेबल, y के लिए ग्राउंड ट्रूथ का प्लॉट. यह प्लॉट कुछ हद तक बांधी गई लहरों की सीरीज़ है.

इमेज 25. एक न्यूमेरिक रिग्रेशन के लिए सिंथेटिक डेटासेट.

 

ग्रेडिएंट को बढ़ाने वाले एल्गोरिदम के पहले सफ़र के बाद, यहां तीन प्लॉट बताए गए हैं:

तीन प्लॉट. पहला प्लॉट मज़बूत मॉडल का अनुमान दिखाता है, जो ढलान 0 और y-इंटरसेप्ट 0 की सीधी लाइन है. दूसरा प्लॉट मज़बूत मॉडल की गड़बड़ी जोड़ता है, जो साइन वेव की सीरीज़ है. तीसरा प्लॉट कमज़ोर मॉडल के अनुमान को दिखाता है, जो कि तरंगों का सेट है.

इमेज 26. पहली बार दोहराने के बाद तीन कहानी.

 

इमेज 26 में मौजूद प्लॉट के बारे में नीचे दी गई बातों पर ध्यान दें:

  • पहला प्लॉट मज़बूत मॉडल का पूर्वानुमान दिखाता है, जो फ़िलहाल हमेशा 0 है.
  • दूसरा प्लॉट गड़बड़ी दिखाता है, जो कि कमज़ोर मॉडल का लेबल है.
  • तीसरा प्लॉट कमज़ोर मॉडल को दिखाता है.

पहला कमज़ोर मॉडल है लेबल का खुरदरापन दिखाना और ज़्यादातर सुविधा के स्पेस के बाएं हिस्से पर फ़ोकस करता है (जिसका सबसे ज़्यादा वैरिएशन होता है और लगातार मैप पर सबसे ज़्यादा गड़बड़ी होती है).

एल्गोरिदम के किसी और वर्शन के लिए भी, ये प्लॉट चुने गए हैं:

तीन प्लॉट. पहला पट दूसरा प्लॉट मज़बूत मॉडल की गड़बड़ी दिखाता है, जो साइन तरंगों का शोर करने वाला सेट है. तीसरा प्लॉट कमज़ोर मॉडल के पूर्वानुमान को दिखाता है, जो कुछ तरंगों वाला है.

इमेज 27. दूसरी बार दोहराने के बाद तीन प्लॉट.

 

इमेज 27 में मौजूद प्लॉट के बारे में इन बातों पर ध्यान दें:

  • अब मज़बूत मॉडल में पिछले पीरियड के कमज़ोर मॉडल का अनुमान है.
  • मज़बूत मॉडल की नई गड़बड़ी कुछ छोटी है.
  • कमज़ोर मॉडल का नया अनुमान, अब सुविधा वाले स्पेस के दाईं ओर है.

हमने एल्गोरिदम को 8 और बार दोहराने के लिए:

प्लॉट, धीरे दिखने वाले मज़बूत मॉडल को दिखाते हैं जबकि कमज़ोर मॉडल का पूर्वानुमान धीरे-धीरे, कमज़ोर होता जाता है.

इमेज 28. तीसरी बार और दसवीं बार करने के बाद तीन प्लॉट.

 

इमेज 28 में, ध्यान रखें कि मज़बूत मॉडल का अनुमान डेटासेट के प्लॉट से मेल खाना चाहिए.

ये आंकड़े, कमज़ोर लर्नर के तौर पर डिसीज़न ट्री का इस्तेमाल करके, ग्रेडिएंट बूस्टिंग एल्गोरिदम को दिखाते हैं. इस कॉम्बिनेशन को ग्रेडिएंट बूस्ट (डिसिज़न) ट्री कहा जाता है.

ऊपर दिए गए प्लॉट, ग्रेडिएंट बूस्ट के अहम हिस्से का सुझाव देते हैं. हालांकि, इस उदाहरण में नीचे दी गई दो असल कार्रवाइयां नहीं हैं:

  • छोटा करना
  • न्यूटन की विधि के एक चरण में लीफ़ वैल्यू को ऑप्टिमाइज़ करना

छोटा करें

कमज़ोर मॉडल $f_i$ को $\nu$ (उदाहरण के लिए, $\nu = 0.1$) की छोटी वैल्यू से गुणा किया जाता है. इसके बाद, इसे मज़बूत मॉडल $F_i$ में जोड़ा जाता है. इस छोटी वैल्यू को श्रिंकेज कहा जाता है. दूसरे शब्दों में, नीचे दिए गए फ़ॉर्मूला का इस्तेमाल करने के बजाय हर बार फिर से:

\[ F_{i+1} = F_i - f_i \]

हर बार इस फ़ॉर्मूला का इस्तेमाल करता है:

\[ F_{i+1} = F_i - \nu f_i \]

ग्रेडिएंट बूस्टिंग में सिकुड़ने से न्यूरल नेटवर्क का लर्निंग रेट बढ़ता जाता है. श्रिंकेज यह कंट्रोल करता है कि मज़बूत मॉडल कितनी तेज़ी से सीख रहा है. इससे ज़्यादा फ़िट होने की ज़रूरत कम होती है. इसका मतलब है कि छोटा करने की वैल्यू 0.0 के नज़दीक है. यह वैल्यू, 1.0 के करीब आने पर, छोटा होने की वैल्यू से ज़्यादा फ़िट हो जाती है.

ऊपर दिए गए हमारे कोड में, छोटा करने की प्रोसेस इस तरह लागू की जाएगी:

shrinkage = 0.1   # 0.1 is a common shrinkage value.
strong_predictions -= shrinkage * weak_predictions
पीछे जाएं
अन्य विषय
आगे बढ़ें
ग्रेडिएंट बूस्टिंग एल्गोरिदम (ज़रूरी नहीं)