डिसिज़न ट्री बनाना

इस यूनिट में, आपको YDF (Yggdrasil डिसीज़न फ़ॉरेस्ट) लाइब्रेरी का इस्तेमाल करके, डिसीज़न ट्री को ट्रेन करना और उसका विश्लेषण करना होगा.

यह यूनिट, 🧭 YDF शुरू करने के बारे में जानकारी देने वाले ट्यूटोरियल से प्रेरित है.

प्रारंभिक दौर

डेटासेट का अध्ययन करने से पहले, ये काम करें:

1. नई Colab नोटबुक बनाएं.
2. अपनी नई Colab नोटबुक में, नीचे दी गई कोड लाइन डालकर और उसे चलाकर, YDF लाइब्रेरी इंस्टॉल करें:

   !pip install ydf -U

3. ये लाइब्रेरी इंपोर्ट करें:

   import ydf
   import numpy as np
   import pandas as pd

Palmer Penguins डेटासेट

इस Colab में, Palmer Penguins डेटासेट का इस्तेमाल किया गया है. इसमें तीन तरह के पेंगुइन के साइज़ की जानकारी शामिल है:

• चिनस्ट्रैप
• Gentoo
• Adelie

यह कैटगरी से जुड़ी समस्या है—इसका लक्ष्य, Palmer's Penguins डेटासेट में मौजूद डेटा के आधार पर, पेंग्विन की प्रजाति का अनुमान लगाना है. यहां पेंगुइन की इमेज दी गई हैं:

16वीं इमेज. पेंग्विन की तीन अलग-अलग प्रजातियां. इमेज क्रेडिट: @allisonhorst

 

यहां दिया गया कोड, Palmer Penguins डेटासेट को मेमोरी में लोड करने के लिए, pandas फ़ंक्शन को कॉल करता है:

path = "https://storage.googleapis.com/download.tensorflow.org/data/palmer_penguins/penguins.csv"
dataset = pd.read_csv(path)
label = "species"

# Display the first 3 examples.
dataset.head(3)

नीचे दी गई टेबल में, Palmer Penguins के डेटासेट के पहले तीन उदाहरणों को फ़ॉर्मैट किया गया है:

तीसरी टेबल. Palmer Penguins में पहले तीन उदाहरण

	प्रजाति	द्वीप	bill_length_mm	bill_depth_mm	flipper_length_mm	body_mass_g	लिंग	साल
0	Adelie	टॉर्गर्सन	39.1	18.7	181.0	3750.0	पुरुष	2007
1	Adelie	टॉर्गर्सन	39.5	17.4	186.0	3800.0	महिला	2007
2	Adelie	टॉर्गर्सन	40.3	18.0	195.0	3250.0	महिला	2007

पूरे डेटासेट में संख्या वाले डेटा (उदाहरण के लिए, bill_depth_mm), कैटगरी वाले डेटा (उदाहरण के लिए, island), और मौजूद नहीं सुविधाओं का मिश्रण होता है. न्यूरल नेटवर्क के उलट, डिसीज़न फ़ॉरेस्ट में इन सभी तरह की सुविधाएं पहले से काम करती हैं. इसलिए, आपको एक-हॉट कोडिंग, नॉर्मलाइज़ेशन या अतिरिक्त is_present सुविधा का इस्तेमाल नहीं करना पड़ता.

नीचे दी गई कोड सेल, डेटासेट को ट्रेनिंग सेट और टेस्टिंग सेट में बांटती है:

# Use the ~20% of the examples as the testing set
# and the remaining ~80% of the examples as the training set.
np.random.seed(1)
is_test = np.random.rand(len(dataset)) < 0.2

train_dataset = dataset[~is_test]
test_dataset = dataset[is_test]

print("Training examples: ", len(train_dataset))
# >> Training examples: 272

print("Testing examples: ", len(test_dataset))
# >> Testing examples: 72

डिफ़ॉल्ट हाइपरपैरामीटर की मदद से, डिसिज़न ट्री को ट्रेनिंग देना

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

model = ydf.CartLearner(label=label).train(train_dataset)

पिछले कॉल में, इनपुट फ़ीचर के तौर पर इस्तेमाल किए जाने वाले कॉलम की जानकारी नहीं दी गई थी. इसलिए, ट्रेनिंग सेट के हर कॉलम का इस्तेमाल किया जाता है. कॉल में, इनपुट फ़ीचर के सेमेटिक्स (उदाहरण के लिए, संख्या, कैटगरी, टेक्स्ट) के बारे में भी नहीं बताया गया था. इसलिए, सुविधा के सेमेटिक्स अपने-आप अनुमानित हो जाते हैं.

नतीजे के तौर पर मिलने वाला डिसीज़न ट्री देखने के लिए, model.plot_tree() को कॉल करें:

model.plot_tree()

Colab में, माउस का इस्तेमाल करके खास एलिमेंट की जानकारी देखी जा सकती है. जैसे, हर नोड में क्लास का डिस्ट्रिब्यूशन.

17वीं इमेज. डिफ़ॉल्ट हाइपरपैरामीटर के साथ ट्रेन किया गया डिसिज़न ट्री.

Colab से पता चलता है कि रूट कंडीशन में 243 उदाहरण हैं. हालांकि, आपको याद होगा कि ट्रेनिंग डेटासेट में 272 उदाहरण थे. बाकी 29 उदाहरणों को, पुष्टि करने और ट्री प्रूनिंग के लिए अपने-आप रिज़र्व कर दिया गया है.

पहली शर्त, bill_depth_mm की वैल्यू की जांच करती है. टेबल 4 और 5 में, पहली शर्त के नतीजे के आधार पर, अलग-अलग प्रजातियों की संभावना दिखाई गई है.

टेबल 4. bill_depth_mm ≥ 42.3 होने पर, अलग-अलग प्रजातियों की संभावना

प्रजाति	संभावना
एडेली (लाल)	8%
Gentoo (नीला)	58%
चिनस्ट्रैप (हरा)	36%

 

टेबल 5. अगर bill_depth_mm < 42.3

प्रजाति	संभावना
एडेली (लाल)	97%
Gentoo (नीला)	2%
चिनस्ट्रैप (हरा)	0%

bill_depth_mm एक संख्यात्मक सुविधा है. इसलिए, संख्यात्मक सुविधाओं के साथ बाइनरी क्लासिफ़िकेशन के लिए सटीक स्प्लिटिंग एल्गोरिदम का इस्तेमाल करके, 42.3 वैल्यू मिली.

अगर bill_depth_mm ≥ 42.3 True है, तो यह जांच करें कि flipper_length_mm ≥ 207.5, Gentoos और Gentoos+Adelie को पूरी तरह से अलग कर सकता है या नहीं.

यहां दिया गया कोड, मॉडल की ट्रेनिंग और जांच के सटीक नतीजे दिखाता है:

train_evaluation = model.evaluate(train_dataset)
print("train accuracy:", train_evaluation.accuracy)
# >> train accuracy:  0.9338

test_evaluation = model.evaluate(test_dataset)
print("test accuracy:", test_evaluation.accuracy)
# >> test accuracy:  0.9167

ऐसा बहुत कम होता है, लेकिन ऐसा हो सकता है कि टेस्ट के नतीजे की सटीकता, ट्रेनिंग के नतीजे की सटीकता से ज़्यादा हो. ऐसे में, हो सकता है कि टेस्ट सेट, ट्रेनिंग सेट से अलग हो. हालांकि, यहां ऐसा नहीं है, क्योंकि ट्रेन और टेस्ट डेटा को अलग-अलग ग्रुप में, रैंडम तरीके से बांटा गया था. इसकी सबसे सही वजह यह है कि टेस्ट डेटासेट बहुत छोटा है (सिर्फ़ 72 उदाहरण). इसलिए, सटीक अनुमान में गड़बड़ी हो सकती है.

आम तौर पर, इस तरह के छोटे डेटासेट के लिए, क्रॉस-वैलिडेशन का इस्तेमाल करना बेहतर होगा. इससे, मेट्रिक की वैल्यू का आकलन ज़्यादा सटीक तरीके से किया जा सकेगा. हालांकि, इस उदाहरण में हम आसानी के लिए, ट्रेनिंग और जांच जारी रखते हैं.

मॉडल के हाइपरपैरामीटर को बेहतर बनाना

यह मॉडल एक डिसिज़न ट्री है, जिसे डिफ़ॉल्ट हाइपरपैरामीटर वैल्यू के साथ ट्रेन किया गया था. बेहतर अनुमान पाने के लिए, ये काम किए जा सकते हैं:

1. ज़्यादा बेहतर लर्नर का इस्तेमाल करें, जैसे कि रैंडम फ़ॉरेस्ट या ग्रेडिएंट बूस्ड ट्री मॉडल. लर्निंग एल्गोरिदम के बारे में अगले पेज पर बताया गया है.

2. अपने अवलोकन और अनुमान का इस्तेमाल करके, हाइपरपैरामीटर को ऑप्टिमाइज़ करें. मॉडल को बेहतर बनाने के लिए बनी गाइड से मदद मिल सकती है.

3. ज़्यादा से ज़्यादा संभावित हाइपरपैरामीटर की अपने-आप जांच करने के लिए, हाइपरपैरामीटर ट्यूनिंग का इस्तेमाल करें.

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

ऊपर दिखाया गया डिसीज़न ट्री छोटा है. साथ ही, 61 के उदाहरण वाले लीफ़ में, अडेली और चिनस्ट्रैप लेबल का मिक्स है. एल्गोरिदम ने इस लीफ को और क्यों नहीं बांटा? इसके दो संभावित कारण हैं:

• हो सकता है कि हर लीफ़ के लिए, सैंपल की कम से कम संख्या (डिफ़ॉल्ट रूप से min_examples=5) पूरी हो गई हो.
• हो सकता है कि ओवरफ़िटिंग को रोकने के लिए, ट्री को बांटा गया हो और फिर उसे छोटा किया गया हो.

उदाहरणों की कम से कम संख्या को एक पर सेट करें और नतीजे देखें:

model = ydf.CartLearner(label=label, min_examples=1).train(train_dataset)
model.plot_tree()

18वीं इमेज. min_examples=1 के साथ ट्रेन किया गया डिसीज़न ट्री.

 

61 उदाहरणों वाले लीफ नोड को कई बार बांटा गया है.

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

print(model.evaluate(test_dataset).accuracy)
# >> 0.97222

मॉडल की क्वालिटी बेहतर हुई है. टेस्ट के सटीक होने का स्कोर 0.9167 से बढ़कर 0.97222 हो गया है. हाइपरपैरामीटर में यह बदलाव करना एक अच्छा आइडिया था.

फ़ैसले के फ़ॉरेस्ट से जुड़ी पिछली जानकारी

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

model = ydf.RandomForestLearner(label=label).train(train_dataset)
print("Test accuracy: ", model.evaluate(test_dataset).accuracy)
# >> Test accuracy: 0.986111

रैंडम फ़ॉरेस्ट, हमारे सामान्य ट्री से ज़्यादा सटीक है. अगले पेजों पर आपको इसकी वजह पता चलेगी.

इस्तेमाल और सीमा

जैसा कि पहले बताया गया है, एक डिसीज़न ट्री की क्वालिटी, अक्सर मशीन लर्निंग के आधुनिक तरीकों जैसे कि रैंडम फ़ॉरेस्ट, ग्रेडिएंट बूस्ड ट्री, और न्यूरल नेटवर्क की तुलना में कम होती है. हालांकि, इन मामलों में डिसीज़न ट्री अब भी काम के हैं:

• ज़्यादा मुश्किल तरीकों का आकलन करने के लिए, एक आसान और कम खर्चीली बेसलाइन के तौर पर.
• जब मॉडल की क्वालिटी और उसे समझने में लगने वाले समय के बीच समझौता करना पड़ता है.
• यह डेसिज़न फ़ॉरेस्ट मॉडल के विश्लेषण के लिए एक प्रॉक्सी के तौर पर काम करता है. इस मॉडल के बारे में इस कोर्स में बाद में बताया जाएगा.