सुपरवाइज़्ड मशीन लर्निंग के सभी मॉडल की तरह ही, डिसीज़न ट्री को ट्रेनिंग के उदाहरणों के सेट को बेहतर तरीके से समझाने के लिए ट्रेन किया जाता है. फ़ैसला लेने वाले ट्री को ऑप्टिमाइज़ करना, एक ऐसी समस्या है जिसे हल करना मुश्किल है. इसलिए, आम तौर पर ट्रेनिंग, हेयुरिस्टिक्स का इस्तेमाल करके की जाती है. यह एक ऐसा लर्निंग एल्गोरिदम है जिसे बनाना आसान होता है. यह फ़ैसला लेने के लिए, ऑप्टिमाइज़ नहीं किया गया, लेकिन ऑप्टिमाइज़ के करीब का ट्री बनाता है.
डिसीज़न ट्री को ट्रेन करने के लिए इस्तेमाल किए जाने वाले ज़्यादातर एल्गोरिदम, 'बहुत ज़्यादा फ़ायदा पाने के लिए बांटकर जीतना' रणनीति के साथ काम करते हैं. एल्गोरिदम, एक नोड (रूट) बनाकर शुरू होता है और फिर बार-बार, ज़्यादा से ज़्यादा नोड जोड़कर डिसीज़न ट्री बनाता है.
हर नोड पर, सभी संभावित शर्तों का आकलन किया जाता है और उन्हें स्कोर दिया जाता है. एल्गोरिदम, "सबसे अच्छी" स्थिति चुनता है. इसका मतलब है कि सबसे ज़्यादा स्कोर वाली स्थिति. फ़िलहाल, बस इतना जान लें कि स्कोर एक ऐसी मेट्रिक है जो टास्क से जुड़ी होती है. साथ ही, उस मेट्रिक को बढ़ाने के लिए शर्तें चुनी जाती हैं.
उदाहरण के लिए, Palmer Penguin डेटासेट (इस कोर्स में बाद में कोड के उदाहरणों के लिए इस्तेमाल किया गया) में, ज़्यादातर Adelie और Chinstrap penguin के चोंच की लंबाई 16 मिमी से ज़्यादा है, जबकि ज़्यादातर Gentoo penguin के चोंच की लंबाई कम है. इसलिए, bill_length_mm ≥ 16 शर्त, जेनतू पेंग्विन के लिए काफ़ी सटीक अनुमान लगाती है. हालांकि, यह अडेली और चिनस्ट्रैप के बीच अंतर नहीं कर सकती. ऐसा हो सकता है कि एल्गोरिदम इस शर्त को चुन ले.
सातवीं इमेज. पेड़ लगाने का पहला चरण.
इसके बाद, एल्गोरिदम दोनों चाइल्ड नोड पर, बार-बार और स्वतंत्र रूप से दोहराया जाता है. जब कोई शर्त पूरी नहीं होती है, तो नोड एक लीफ़ बन जाता है. लीफ़ के लिए अनुमान, उदाहरणों में सबसे ज़्यादा प्रतिनिधि लेबल वैल्यू के तौर पर तय किया जाता है.
एल्गोरिदम इस तरह काम करता है:
def train_decision_tree(training_examples):
root = create_root() # Create a decision tree with a single empty root.
grow_tree(root, training_examples) # Grow the root node.
return root
def grow_tree(node, examples):
condition = find_best_condition(examples) # Find the best condition.
if condition is None:
# No satisfying conditions were found, therefore the grow of the branch stops.
set_leaf_prediction(node, examples)
return
# Create two childrens for the node.
positive_child, negative_child = split_node(node, condition)
# List the training examples used by each children.
negative_examples = [example for example in examples if not condition(example)]
positive_examples = [example for example in examples if condition(example)]
# Continue the growth of the children.
grow_tree(negative_child, negative_examples)
grow_tree(positive_child, positive_examples)
चलिए, किसी खास डिसीज़न ट्री को ट्रेन करने के बारे में ज़्यादा जानकारी के साथ जानें.
पहला चरण: रूट बनाएं:
दूसरा चरण: पहला नोड बड़ा करें. "x1 ≥ 1" शर्त मिली. दो चाइल्ड नोड बनाए जाते हैं:
तीसरा चरण: दूसरा नोड बढ़ाएं. कोई भी शर्त पूरी नहीं हुई. इसलिए, नोड को लीफ में बदलें:
चौथा चरण: नोड #3 को बड़ा करें. "x2 ≥ 0.5" शर्त मिली. दो चाइल्ड node बनाए जाते हैं.
डिसीज़न ट्री बनाने के लिए, दूसरे तरीके भी मौजूद हैं. 'अलग-अलग हिस्सों में बांटकर काम करना' रणनीति का इस्तेमाल करने के बजाय, दुनिया भर में नोड को ऑप्टिमाइज़ करना एक लोकप्रिय विकल्प है.
growing_strategy="BEST_FIRST_GLOBAL" पैरामीटर की मदद से ग्लोबल ग्रॉथ को चालू किया जा सकता है.
ज़्यादा जानकारी के लिए,
दस्तावेज़ देखें.
इनपुट फ़ीचर की संख्या और टाइप के आधार पर, किसी दिए गए नोड के लिए संभावित स्थितियों की संख्या बहुत ज़्यादा हो सकती है. आम तौर पर, यह संख्या अनलिमिटेड होती है. उदाहरण के लिए, थ्रेशोल्ड की शर्त $\mathrm{feature}_i \geq t$ के लिए, $t \in \mathbb{R}$ के लिए सभी संभावित थ्रेशोल्ड वैल्यू का कॉम्बिनेशन अनंत है.
सबसे अच्छी स्थिति का पता लगाने वाले रूटीन को स्प्लिटर कहा जाता है. डिसिज़न ट्री को ट्रेनिंग देने के दौरान, स्प्लिटर सबसे बड़ी समस्या होते हैं, क्योंकि उन्हें कई संभावित स्थितियों की जांच करनी होती है.
स्प्लिटर से ज़्यादा से ज़्यादा स्कोर मिलना, टास्क पर निर्भर करता है. उदाहरण के लिए:
- डेटा को अलग-अलग ग्रुप में बांटने के लिए, आम तौर पर जानकारी हासिल करने और Gini का इस्तेमाल किया जाता है. इन दोनों के बारे में बाद में बताया जाएगा.
- आम तौर पर, वर्ग में गड़बड़ी का माध्य, रेग्रेशन के लिए इस्तेमाल किया जाता है.
डेटा को अलग-अलग हिस्सों में बांटने के लिए कई एल्गोरिद्म उपलब्ध हैं. इनमें से हर एल्गोरिद्म के लिए, ये काम अलग-अलग तरीके से किए जाते हैं:
- सुविधाओं का टाइप; उदाहरण के लिए, संख्या, कैटगरी, टेक्स्ट
- टास्क; उदाहरण के लिए, बाइनरी क्लासिफ़िकेशन, मल्टी-क्लास क्लासिफ़िकेशन, रिग्रेशन
- शर्त का टाइप; उदाहरण के लिए, थ्रेशोल्ड शर्त, इन-सेट शर्त, ओब्लिक शर्त
- डेटा को नियमित करने की शर्तें; उदाहरण के लिए, थ्रेशोल्ड की शर्तों के लिए सटीक या अनुमानित स्प्लिटर
इसके अलावा, मेमोरी के इस्तेमाल, सीपीयू के इस्तेमाल, कैलकुलेशन डिस्ट्रिब्यूशन वगैरह के मामले में अलग-अलग ट्रेड-ऑफ़ के साथ, स्प्लिटर के बराबर वैरिएंट भी मौजूद हैं.