👨🏾‍🎓 🙎🏼 🎵 XGBoost के अंदर क्या है, और Go को इससे क्या लेना देना है? ⛹🏼 🎾 🍺

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

एक ही लेख में, हम पहले से ही प्रशिक्षित पेड़ पहनावा मॉडल से भविष्यवाणियों को उत्पन्न करने की प्रक्रिया पर विचार करेंगे, लोकप्रिय ग्रेडिंग बूस्टिंग XGBoost और LightGBM में कार्यान्वयन सुविधाएँ। और पाठक को गो के लिए leaves पुस्तकालय से भी परिचित कराया जाएगा, जो आपको मूल पुस्तकालयों के सी एपीआई का उपयोग किए बिना पेड़ टुकड़ियों के लिए भविष्यवाणियां करने की अनुमति देता है।

पेड़ कहाँ से उगते हैं?

पहले सामान्य प्रावधानों पर विचार करें। वे आमतौर पर पेड़ों के साथ काम करते हैं, जहां:

नोड में विभाजन एक विशेषता के अनुसार होता है
बाइनरी ट्री - प्रत्येक नोड में एक बाएं और दाएं वंशज हैं
एक भौतिक विशेषता के मामले में, निर्णय नियम में विशेषता के मूल्य की सीमा मूल्य के साथ तुलना करना शामिल है

मैंने इस चित्रण को XGBoost प्रलेखन से लिया है

इस पेड़ में हमारे 2 नोड्स, 2 निर्णय नियम और 3 शीट हैं। मंडलियों के तहत, मूल्यों को इंगित किया जाता है - किसी वस्तु को पेड़ लगाने का परिणाम। आमतौर पर, एक परिवर्तन फ़ंक्शन एक पेड़ या पेड़ की टुकड़ी की गणना के परिणाम पर लागू होता है। उदाहरण के लिए, एक द्विआधारी वर्गीकरण समस्या के लिए एक सिग्मॉइड ।

धीरे-धीरे बूस्टिंग द्वारा प्राप्त पेड़ों की टुकड़ी से पूर्वानुमान प्राप्त करने के लिए, आपको सभी पेड़ों की भविष्यवाणियों के परिणामों को जोड़ना होगा:

 double pred = 0.0; for (auto& tree: trees) pred += tree->Predict(feature_values);

इसके बाद, C++ , जैसा कि यह इस भाषा में है कि XGBoost और LightGBM लिखा जाता है। मैं अप्रासंगिक विवरणों को छोड़ दूंगा और सबसे संक्षिप्त कोड देने का प्रयास करूंगा।

अगला, विचार करें कि Predict में क्या छिपा है और पेड़ की डेटा संरचना कैसे संरचित है।

XGBoost पेड़

XGBoost में XGBoost की कई कक्षाएं (OOP के अर्थ में) हैं। हम RegTree बारे में बात करेंगे (देखें include/xgboost/tree_model.h ), जो प्रलेखन के अनुसार, मुख्य है। यदि आप केवल अनुमानों के लिए महत्वपूर्ण विवरण छोड़ देते हैं, तो कक्षा के सदस्य यथासंभव सरल दिखते हैं:

 class RegTree { // vector of nodes std::vector<Node> nodes_; };

GetNext नियम GetNext फ़ंक्शन में कार्यान्वित किया GetNext है। गणना के परिणाम को प्रभावित किए बिना, कोड को थोड़ा संशोधित किया गया है:

 // get next position of the tree given current pid int RegTree::GetNext(int pid, float fvalue, bool is_unknown) const { const auto& node = nodes_[pid] float split_value = node.info_.split_cond; if (is_unknown) { return node.DefaultLeft() ? node.cleft_ : node.cright_; } else { if (fvalue < split_value) { return node.cleft_; } else { return node.cright_; } } }

यहाँ से दो बातें अनुसरण करती हैं:

RegTree केवल वास्तविक विशेषताओं के साथ काम करता है (प्रकार float )
स्किप किए गए चारित्रिक मूल्य समर्थित हैं

केंद्र बिंदु Node वर्ग है। इसमें पेड़ की स्थानीय संरचना, निर्णय नियम और शीट का मूल्य शामिल है:

 class Node { public: // feature index of split condition unsigned SplitIndex() const { return sindex_ & ((1U << 31) - 1U); } // when feature is unknown, whether goes to left child bool DefaultLeft() const { return (sindex_ >> 31) != 0; } // whether current node is leaf node bool IsLeaf() const { return cleft_ == -1; } private: // in leaf node, we have weights, in non-leaf nodes, we have split condition union Info { float leaf_value; float split_cond; } info_; // pointer to left, right int cleft_, cright_; // split feature index, left split or right split depends on the highest bit unsigned sindex_{0}; };

निम्नलिखित विशेषताओं को प्रतिष्ठित किया जा सकता है:

चादरों को नोड्स के रूप में दर्शाया जाता है जिसके लिए cleft_ = -1
info_ फ़ील्ड को union रूप union दर्शाया गया है, अर्थात दो प्रकार के डेटा (इस मामले में समान) नोड के प्रकार के आधार पर मेमोरी का एक टुकड़ा साझा करते हैं
sindex_ में सबसे महत्वपूर्ण बिट उस वस्तु के लिए ज़िम्मेदार होता है, जिसका गुण मान छोड़ दिया जाता है

RegTree::Predict उत्तर प्राप्त करने की RegTree::Predict विधि को कॉल करने से मार्ग का पता लगाने में सक्षम होने के लिए, मैं दो बार गायब हो जाएगा:

 float RegTree::Predict(const RegTree::FVec& feat, unsigned root_id) const { int pid = this->GetLeafIndex(feat, root_id); return nodes_[pid].leaf_value; } int RegTree::GetLeafIndex(const RegTree::FVec& feat, unsigned root_id) const { auto pid = static_cast<int>(root_id); while (!nodes_[pid].IsLeaf()) { unsigned split_index = nodes_[pid].SplitIndex(); pid = this->GetNext(pid, feat.Fvalue(split_index), feat.IsMissing(split_index)); } return pid; }

GetLeafIndex फ़ंक्शन में GetLeafIndex हम पेड़ के नोड्स को एक लूप में नीचे GetLeafIndex जब तक हम पत्ती को नहीं मारते।

लाइट जीबीएम ट्रीज़

लाइट जीबीएम में नोड के लिए डेटा संरचना नहीं है। इसके बजाय, ट्री Tree की डेटा संरचना ( include/LightGBM/tree.h फ़ाइल शामिल है) में मूल्यों के एरे शामिल हैं, जहां नोड संख्या एक सूचकांक के रूप में उपयोग की जाती है। पत्तियों में मूल्यों को अलग-अलग सरणियों में भी संग्रहीत किया जाता है।

 class Tree { // Number of current leaves int num_leaves_; // A non-leaf node's left child std::vector<int> left_child_; // A non-leaf node's right child std::vector<int> right_child_; // A non-leaf node's split feature, the original index std::vector<int> split_feature_; //A non-leaf node's split threshold in feature value std::vector<double> threshold_; std::vector<int> cat_boundaries_; std::vector<uint32_t> cat_threshold_; // Store the information for categorical feature handle and mising value handle. std::vector<int8_t> decision_type_; // Output of leaves std::vector<double> leaf_value_; };

LightGBM श्रेणीबद्ध विशेषताओं का समर्थन करता है। समर्थन एक बिट फ़ील्ड का उपयोग करके प्रदान किया जाता है, जो सभी नोड्स के लिए cat_threshold_ में संग्रहीत होता है। cat_boundaries_ उस नोड को संग्रहीत करता है जो बिट फ़ील्ड के किस भाग से मेल खाती है। श्रेणीबद्ध मामले के लिए threshold_ फ़ील्ड को int में cat_boundaries_ जाता है और बिट क्षेत्र की शुरुआत के लिए खोज करने के लिए cat_boundaries_ में सूचकांक से मेल खाती है।

एक स्पष्ट विशेषता के लिए निर्णायक नियम पर विचार करें:

 int CategoricalDecision(double fval, int node) const { uint8_t missing_type = GetMissingType(decision_type_[node]); int int_fval = static_cast<int>(fval); if (int_fval < 0) { return right_child_[node];; } else if (std::isnan(fval)) { // NaN is always in the right if (missing_type == 2) { return right_child_[node]; } int_fval = 0; } int cat_idx = static_cast<int>(threshold_[node]); if (FindInBitset(cat_threshold_.data() + cat_boundaries_[cat_idx], cat_boundaries_[cat_idx + 1] - cat_boundaries_[cat_idx], int_fval)) { return left_child_[node]; } return right_child_[node]; }

यह देखा जा सकता है कि, missing_type आधार पर missing_type मान NaN स्वचालित रूप से पेड़ की दाईं शाखा के साथ समाधान को कम करता है। अन्यथा, NaN को 0. से बदल दिया जाता है। बिट क्षेत्र में मान की खोज करना काफी सरल है:

 bool FindInBitset(const uint32_t* bits, int n, int pos) { int i1 = pos / 32; if (i1 >= n) { return false; } int i2 = pos % 32; return (bits[i1] >> i2) & 1; }

यानी, उदाहरण के लिए, श्रेणीबद्ध विशेषता int_fval=42 जाँच की int_fval=42 है कि क्या सरणी में 41 वां (0 से क्रमांकन) बिट सेट है या नहीं।

इस दृष्टिकोण में एक महत्वपूर्ण कमी है: यदि एक श्रेणीगत विशेषता बड़े मान ले सकती है, उदाहरण के लिए 100500, तो इस विशेषता के लिए प्रत्येक निर्णय नियम के लिए आकार में 12564 बाइट्स तक एक बिट फ़ील्ड बनाया जाएगा!

इसलिए, श्रेणीबद्ध विशेषताओं के मूल्यों को फिर से स्थापित करना वांछनीय है ताकि वे 0 से अधिकतम मूल्य तक लगातार जाएं ।

अपने हिस्से के लिए, मैंने LightGBM व्याख्यात्मक परिवर्तन किए और उन्हें स्वीकार किया ।

भौतिक विशेषताओं के साथ व्यवहार करना XGBoost से बहुत अलग नहीं है, और मैं इसे संक्षिप्तता के लिए छोड़ दूंगा।

पत्तियां - गो में भविष्यवाणियों के लिए पुस्तकालय

XGBoost और LightGBM निर्णय पेड़ों पर ढाल LightGBM मॉडल के निर्माण के लिए बहुत शक्तिशाली पुस्तकालय हैं। बैकएंड सेवा में उनका उपयोग करने के लिए, जहां मशीन लर्निंग एल्गोरिदम की आवश्यकता होती है, निम्नलिखित कार्यों को हल करना आवश्यक है:

मॉडल का आवधिक प्रशिक्षण ऑफ़लाइन
बैकएंड सेवा में मॉडल का वितरण
पोल मॉडल ऑनलाइन

भरी हुई बैकेंड सेवा लिखने के लिए, Go एक लोकप्रिय भाषा है। C API और LightGBM माध्यम से XGBoost या LightGBM XGBoost सबसे आसान समाधान नहीं है - प्रोग्राम का निर्माण जटिल है, लापरवाह हैंडलिंग के कारण, आप SIGTERM को पकड़ सकते हैं, सिस्टम थ्रेड्स की संख्या के साथ समस्याएं (लाइब्रेरी के साथ ओपनएमपी बनाम रनटाइम थ्रेड्स)।

इसलिए मैंने XGBoost या LightGBM में निर्मित मॉडलों का उपयोग करके भविष्यवाणियों के लिए शुद्ध Go पर एक लाइब्रेरी लिखने का फैसला किया। इसे leaves कहते leaves ।

पत्ते

पुस्तकालय की मुख्य विशेषताएं:

LightGBM मॉडल के लिए
- मानक प्रारूप (पाठ) से मॉडल पढ़ना
- भौतिक और श्रेणीबद्ध विशेषताओं के लिए समर्थन
- गुम मान समर्थन
- श्रेणीबद्ध चर के साथ काम का अनुकूलन
- भविष्यवाणी-केवल डेटा संरचनाओं के साथ भविष्यवाणी अनुकूलन
XGBoost मॉडल के लिए
- मानक प्रारूप (बाइनरी) से मॉडल पढ़ना
- गुम मान समर्थन
- भविष्यवाणी अनुकूलन

यहां एक न्यूनतम Go कार्यक्रम है जो डिस्क से एक मॉडल को लोड करता है और एक भविष्यवाणी दिखाता है:

 package main import ( "bufio" "fmt" "os" "github.com/dmitryikh/leaves" ) func main() { // 1.     path := "lightgbm_model.txt" reader, err := os.Open(path) if err != nil { panic(err) } defer reader.Close() // 2.   LightGBM model, err := leaves.LGEnsembleFromReader(bufio.NewReader(reader)) if err != nil { panic(err) } // 3.  ! fvals := []float64{1.0, 2.0, 3.0} p := model.Predict(fvals, 0) fmt.Printf("Prediction for %v: %f\n", fvals, p) }

लाइब्रेरी API न्यूनतम है। XGBoost मॉडल का उपयोग करने के लिए XGBoost बस ऊपर दिए गए leaves.XGEnsembleFromReader बजाय leaves.XGEnsembleFromReader कॉल करें। leaves.XGEnsembleFromReader विधि। भविष्यवाणियों को PredictDense या model.PredictCSR को कॉल करके बनाया जा सकता है। पत्तियों के परीक्षणों में अधिक उपयोग परिदृश्य पाए जा सकते हैं।

इस तथ्य के बावजूद कि Go , C++ की तुलना में धीमी गति से चलता है (मुख्य रूप से भारी रनटाइम और रनटाइम चेक के कारण), कई अनुकूलन के लिए धन्यवाद, मूल पुस्तकालयों के सी एपीआई को कॉल करने के लिए तुलनीय भविष्यवाणी गति प्राप्त करना संभव था।

तुलना के परिणामों और विधि के बारे में अधिक जानकारी जीथब पर रिपॉजिटरी में हैं।

जड़ को देखें

मुझे उम्मीद है कि यह लेख XGBoost और LightGBM में पेड़ों के कार्यान्वयन के लिए द्वार खोलता है। जैसा कि आप देख सकते हैं, बुनियादी निर्माण काफी सरल हैं, और मैं पाठकों को खुले स्रोत का लाभ उठाने के लिए प्रोत्साहित करता हूं - कोड का अध्ययन करने के लिए जब यह काम करता है के बारे में प्रश्न हैं।

उन लोगों के लिए जो गो भाषा में अपनी सेवाओं में ढाल बढ़ाने वाले मॉडल का उपयोग करने के विषय में रुचि रखते हैं, मैं सुझाव देता हूं कि आप खुद को पत्तियों के पुस्तकालय से परिचित कराएं। leaves का उपयोग करते हुए leaves आप मूल C ++ कार्यान्वयन की तुलना में गति खोए बिना, अपने उत्पादन परिवेश में मशीन लर्निंग में अग्रणी बढ़त समाधानों का आसानी से उपयोग कर सकते हैं।

अ छा!

XGBoost के अंदर क्या है, और Go को इससे क्या लेना देना है?

पेड़ कहाँ से उगते हैं?

XGBoost पेड़

लाइट जीबीएम ट्रीज़

पत्तियां - गो में भविष्यवाणियों के लिए पुस्तकालय

जड़ को देखें

More articles: