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

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

  • "कमज़ोर" मशीन लर्निंग मॉडल है, जो आम तौर पर डिसिज़न ट्री होता है.
  • "मज़बूत" मशीन लर्निंग मॉडल, जो कई सारे जोखिमों से बना होता है मॉडल.

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

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

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

कहां:

  • $i$ चरण में $F_i$ एक मज़बूत मॉडल है.
  • $i$ चरण पर $f_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 में, प्लॉट के बारे में नीचे दी गई बातों को नोट करें:

  • मज़बूत मॉडल में अब पिछली बार दोहराना.
  • मज़बूत मॉडल की नई गड़बड़ी थोड़ी छोटी है.
  • कमज़ोर मॉडल के नए अनुमान का फ़ोकस, अब उस फ़ीचर स्पेस.

हम एल्गोरिदम को आठ और बार-बार आज़माते हैं:

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

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

 

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

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

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

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

श्रिंकेज

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

\[ 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
पीछे जाएं
अन्य विषय
आगे बढ़ें
ग्रेडिएंट बूस्टिंग एल्गोरिदम (ज़रूरी नहीं)