Python में Decision Tree Classification ट्यूटोरियल

डिसीज़न ट्री एल्गोरिद्म

डिसीज़न ट्री एक फ्लोचार्ट-जैसी ट्री संरचना है जहाँ एक इंटरनल नोड किसी फीचर (या एट्रिब्यूट) का प्रतिनिधित्व करता है, ब्रांच एक निर्णय नियम का प्रतिनिधित्व करती है, और प्रत्येक लीफ नोड परिणाम का प्रतिनिधित्व करता है।

डिसीज़न ट्री में सबसे ऊपर का नोड रूट नोड कहलाता है। यह एट्रिब्यूट वैल्यू के आधार पर पार्टिशन करना सीखता है। यह ट्री को पुनरावर्ती तरीके से विभाजित करता है जिसे रिकर्सिव पार्टिशनिंग कहते हैं। यह फ्लोचार्ट-जैसी संरचना निर्णय लेने में आपकी मदद करती है। इसका विज़ुअलाइज़ेशन एक फ्लोचार्ट डायग्राम जैसा होता है जो आसानी से मानव-स्तरीय सोच की नकल करता है। यही कारण है कि डिसीज़न ट्री समझने और व्याख्या करने में आसान हैं।

डिसीज़न ट्री एल्गोरिद्म। चित्र: Abid Ali Awan

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

डिसीज़न ट्री की समय जटिलता दिए गए डेटा में रिकॉर्ड और एट्रिब्यूट की संख्या का एक फंक्शन है। डिसीज़न ट्री एक डिस्ट्रीब्यूशन-फ्री या नॉन-पैरामेट्रिक विधि है जो डेटा के अंतर्निहित प्रायिकता वितरण के बारे में धारणाओं पर निर्भर नहीं होती। डिसीज़न ट्री उच्च-आयामी डेटा को अच्छी सटीकता के साथ संभाल सकते हैं।

डिसीज़न ट्री एल्गोरिद्म कैसे काम करता है?

किसी भी डिसीज़न ट्री एल्गोरिद्म के पीछे बुनियादी विचार इस प्रकार है:

1. रिकॉर्ड को विभाजित करने के लिए एट्रिब्यूट सेलेक्शन मेजर्स (ASM) का उपयोग करके सर्वोत्तम एट्रिब्यूट चुनें।
2. उस एट्रिब्यूट को एक निर्णय नोड बनाएं और डेटासेट को छोटे सबसेट में बाँट दें।
3. प्रत्येक चाइल्ड के लिए इस प्रक्रिया को रिकर्सिव रूप से दोहराकर ट्री बनाना शुरू करें जब तक कि इनमें से कोई एक शर्त पूरी न हो जाए:
   • सभी ट्यूपल एक ही एट्रिब्यूट वैल्यू से संबंधित हों।
   • और एट्रिब्यूट शेष न हों।
   • और इंस्टैंस शेष न हों।

एट्रिब्यूट सेलेक्शन मेजर्स

एट्रिब्यूट सेलेक्शन मेजर डेटा को सर्वोत्तम तरीके से विभाजित करने के लिए स्प्लिटिंग क्राइटेरियन चुनने की एक ह्यूरिस्टिक है। इसे स्प्लिटिंग रूल्स भी कहा जाता है क्योंकि यह किसी दिए गए नोड पर ट्यूपल्स के लिए ब्रेकपॉइंट निर्धारित करने में मदद करता है। ASM दिए गए डेटासेट को समझाकर प्रत्येक फीचर (या एट्रिब्यूट) को एक रैंक देता है। सर्वश्रेष्ठ स्कोर वाला एट्रिब्यूट स्प्लिटिंग एट्रिब्यूट के रूप में चुना जाएगा। निरंतर-मूल्य वाले एट्रिब्यूट के मामले में, ब्रांच के लिए स्प्लिट पॉइंट भी परिभाषित करने होते हैं। सबसे लोकप्रिय सेलेक्शन मेजर्स हैं Information Gain, Gain Ratio, और Gini Index।

इन्फॉर्मेशन गेन

क्लॉड शैनन ने एंट्रॉपी की संकल्पना का आविष्कार किया, जो इनपुट सेट की अशुद्धि को मापती है। भौतिकी और गणित में, एंट्रॉपी किसी सिस्टम में रैंडमनेस या अशुद्धि को संदर्भित करती है। सूचना सिद्धांत में, यह उदाहरणों के समूह में अशुद्धि को संदर्भित करती है। इन्फॉर्मेशन गेन एंट्रॉपी में कमी है। इन्फॉर्मेशन गेन, दिए गए एट्रिब्यूट वैल्यू के आधार पर डेटासेट के स्प्लिट से पहले की एंट्रॉपी और स्प्लिट के बाद औसत एंट्रॉपी के बीच का अंतर गणना करता है। ID3 (Iterative Dichotomiser) डिसीज़न ट्री एल्गोरिद्म इन्फॉर्मेशन गेन का उपयोग करता है।

जहाँ Pi वह प्रायिकता है कि D में कोई भी मनमाना ट्यूपल क्लास Ci से संबंधित है।

जहाँ:

• Info(D) वह औसत सूचना की मात्रा है जो D में किसी ट्यूपल के क्लास लेबल की पहचान करने के लिए आवश्यक है।

• |Dj|/|D| j^वें पार्टिशन का वज़न है।

• InfoA(D) वह अपेक्षित सूचना है जो A द्वारा पार्टिशनिंग के आधार पर D से किसी ट्यूपल को वर्गीकृत करने के लिए आवश्यक है।

सबसे अधिक इन्फॉर्मेशन गेन, Gain(A), वाला एट्रिब्यूट नोड N() पर स्प्लिटिंग एट्रिब्यूट के रूप में चुना जाता है।

गेन रेशियो

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

ID3 के एक सुधार C4.5 में इन्फॉर्मेशन गेन के विस्तार, जिसे गेन रेशियो कहते हैं, का उपयोग किया जाता है। गेन रेशियो, Split Info का उपयोग करके इन्फॉर्मेशन गेन को नॉर्मलाइज़ कर पक्षपात की समस्या को संभालता है। C4.5 एल्गोरिद्म का Java इम्प्लीमेंटेशन J48 के नाम से जाना जाता है, जो WEKA डेटा माइनिंग टूल में उपलब्ध है।

जहाँ:

• |Dj|/|D| jवें पार्टिशन का वज़न है।
• v एट्रिब्यूट A में डिस्क्रीट वैल्यू की संख्या है।

गेन रेशियो को इस प्रकार परिभाषित किया जा सकता है

सबसे अधिक गेन रेशियो वाला एट्रिब्यूट स्प्लिटिंग एट्रिब्यूट के रूप में चुना जाता है (स्रोत).

जिनी इंडेक्स

एक अन्य डिसीज़न ट्री एल्गोरिद्म CART (Classification and Regression Tree) स्प्लिट पॉइंट बनाने के लिए Gini विधि का उपयोग करता है।

जहाँ pi वह प्रायिकता है कि D में कोई ट्यूपल क्लास Ci से संबंधित है।

जिनी इंडेक्स प्रत्येक एट्रिब्यूट के लिए बाइनरी स्प्लिट पर विचार करता है। आप प्रत्येक पार्टिशन की अशुद्धि का वेटेड सम गणना कर सकते हैं। यदि एट्रिब्यूट A पर एक बाइनरी स्प्लिट डेटा D को D1 और D2 में विभाजित करता है, तो D का जिनी इंडेक्स होगा:

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

न्यूनतम जिनी इंडेक्स वाला एट्रिब्यूट स्प्लिटिंग एट्रिब्यूट के रूप में चुना जाता है।

Scikit-learn में डिसीज़न ट्री क्लासिफायर बनाना

आवश्यक लाइब्रेरी आयात करना

पहले आवश्यक लाइब्रेरी लोड करते हैं।

# Load libraries
import pandas as pd
from sklearn.tree import DecisionTreeClassifier # Import Decision Tree Classifier
from sklearn.model_selection import train_test_split # Import train_test_split function
from sklearn import metrics #Import scikit-learn metrics module for accuracy calculation

डेटा लोड करना

सबसे पहले pandas की read CSV फ़ंक्शन का उपयोग करके आवश्यक Pima Indian Diabetes डेटासेट लोड करते हैं। साथ चलने के लिए आप Kaggle डेटासेट डाउनलोड कर सकते हैं।

col_names = ['pregnant', 'glucose', 'bp', 'skin', 'insulin', 'bmi', 'pedigree', 'age', 'label']
# load dataset
pima = pd.read_csv("diabetes.csv", header=None, names=col_names)

pima.head()

फ़ीचर चयन

यहाँ, आपको दी गई कॉलमों को दो प्रकार के वेरिएबल में बाँटना है—निर्भर (या टार्गेट वेरिएबल) और स्वतंत्र वेरिएबल (या फीचर वेरिएबल)।

#split dataset in features and target variable
feature_cols = ['pregnant', 'insulin', 'bmi', 'age','glucose','bp','pedigree']
X = pima[feature_cols] # Features
y = pima.label # Target variable

डेटा विभाजित करना

मॉडल के प्रदर्शन को समझने के लिए, डेटासेट को ट्रेनिंग सेट और टेस्ट सेट में विभाजित करना एक अच्छा तरीका है।

आइए train_test_split() फ़ंक्शन का उपयोग करके डेटासेट को विभाजित करें। आपको तीन पैरामीटर पास करने होंगे: फीचर्स, टार्गेट और टेस्ट सेट का आकार।

# Split dataset into training set and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1) # 70% training and 30% test

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

आइए Scikit-learn का उपयोग करके एक डिसीज़न ट्री मॉडल बनाते हैं।

# Create Decision Tree classifer object
clf = DecisionTreeClassifier()

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

मॉडल का मूल्यांकन

आइए अनुमान लगाएँ कि क्लासिफायर या मॉडल कितनी सटीकता से कल्टीवर के प्रकार की भविष्यवाणी कर सकता है।

सटीकता वास्तविक टेस्ट सेट वैल्यू और भविष्यवाणी की गई वैल्यू की तुलना करके निकाली जा सकती है।

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))

Accuracy: 0.6753246753246753

हमें 67.53% का क्लासिफिकेशन रेट मिला, जिसे अच्छी सटीकता माना जाता है। आप डिसीज़न ट्री एल्गोरिद्म में पैरामीटर ट्यूनिंग करके इस सटीकता में सुधार कर सकते हैं।

डिसीज़न ट्री का विज़ुअलाइज़ेशन

आप Jupyter नोटबुक में ट्री प्रदर्शित करने के लिए Scikit-learn के export_graphviz() फ़ंक्शन का उपयोग कर सकते हैं। ट्री प्लॉट करने के लिए, आपको graphviz और pydotplus भी इंस्टॉल करने होंगे।

pip install graphviz
pip install pydotplus

export_graphviz() फ़ंक्शन डिसीज़न ट्री क्लासिफायर को डॉट फ़ाइल में बदल देता है, और pydotplus इस डॉट फ़ाइल को PNG या Jupyter पर प्रदर्शनीय रूप में बदलता है।

from sklearn.tree import export_graphviz
from sklearn.externals.six import StringIO  
from IPython.display import Image  
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True,feature_names = feature_cols,class_names=['0','1'])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
graph.write_png('diabetes.png')
Image(graph.create_png())

डिसीज़न ट्री चार्ट में, प्रत्येक इंटरनल नोड में एक निर्णय नियम होता है जो डेटा को विभाजित करता है। Gini, जिसे Gini रेशियो कहा जाता है, नोड की अशुद्धि को मापता है। आप कह सकते हैं कि कोई नोड तब शुद्ध होता है जब उसके सभी रिकॉर्ड एक ही क्लास से संबंधित होते हैं; ऐसे नोड्स को लीफ नोड कहा जाता है।

यहाँ, प्राप्त ट्री अनप्रूनड है। यह अनप्रूनड ट्री समझाना कठिन है और आसानी से समझ में नहीं आता। अगले सेक्शन में, प्रूनिंग करके इसे ऑप्टिमाइज़ करते हैं।

डिसीज़न ट्री का प्रदर्शन ऑप्टिमाइज़ करना

• criterion: वैकल्पिक (डिफ़ॉल्ट=”gini”) या एट्रिब्यूट सेलेक्शन मेजर चुनें। यह पैरामीटर हमें अलग-अलग एट्रिब्यूट सेलेक्शन मेजर का उपयोग करने की अनुमति देता है। समर्थित क्राइटेरिया हैं “gini” Gini इंडेक्स के लिए और “entropy” इन्फॉर्मेशन गेन के लिए।

• splitter: स्ट्रिंग, वैकल्पिक (डिफ़ॉल्ट=”best”) या स्प्लिट रणनीति। यह पैरामीटर हमें स्प्लिट रणनीति चुनने देता है। समर्थित रणनीतियाँ हैं “best” सर्वश्रेष्ठ स्प्लिट चुनने के लिए और “random” सर्वश्रेष्ठ रैंडम स्प्लिट चुनने के लिए।

• max_depth: int या None, वैकल्पिक (डिफ़ॉल्ट=None) या ट्री की अधिकतम गहराई। ट्री की अधिकतम गहराई। यदि None है, तो नोड्स का विस्तार तब तक किया जाता है जब तक कि सभी लीव्स में min_samples_split से कम सैंपल न रह जाएँ। अधिकतम गहराई का अधिक मान ओवरफिटिंग का कारण बनता है, और कम मान अंडरफिटिंग का कारण (स्रोत).

Scikit-learn में, डिसीज़न ट्री क्लासिफायर का ऑप्टिमाइज़ेशन केवल प्री-प्रूनिंग द्वारा किया जाता है। ट्री की अधिकतम गहराई को प्री-प्रूनिंग के लिए एक नियंत्रण चर के रूप में उपयोग किया जा सकता है। निम्न उदाहरण में, आप उसी डेटा पर max_depth=3 के साथ एक डिसीज़न ट्री प्लॉट कर सकते हैं। प्री-प्रूनिंग पैरामीटर के अलावा, आप entropy जैसे अन्य एट्रिब्यूट सेलेक्शन मेजर भी आज़मा सकते हैं।

# Create Decision Tree classifer object
clf = DecisionTreeClassifier(criterion="entropy", max_depth=3)

# Train Decision Tree Classifer
clf = clf.fit(X_train,y_train)

#Predict the response for test dataset
y_pred = clf.predict(X_test)

# Model Accuracy, how often is the classifier correct?
print("Accuracy:",metrics.accuracy_score(y_test, y_pred))
Accuracy: 0.7705627705627706

ठीक है, क्लासिफिकेशन रेट बढ़कर 77.05% हो गया, जो पिछले मॉडल की सटीकता से बेहतर है।

आइए निम्नलिखित कोड का उपयोग करके अपने डिसीज़न ट्री को थोड़ा और आसानी से समझने योग्य बनाते हैं: 

from six import StringIO
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus

dot_data = StringIO()
export_graphviz(clf, out_file=dot_data, 
                filled=True, 
                rounded=True, 
                special_characters=True, 
                feature_names=feature_cols,
                class_names=['0','1'])

graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
graph.write_png('diabetes.png')
Image(graph.create_png())

यहाँ, हमने निम्नलिखित चरण पूरे किए हैं: 

• आवश्यक लाइब्रेरी आयात कीं।

• dot_data नाम का एक StringIO ऑब्जेक्ट बनाया जो डिसीज़न ट्री के टेक्स्ट प्रतिनिधित्व को रखेगा।

• export_graphviz फ़ंक्शन का उपयोग करके डिसीज़न ट्री को dot फ़ॉर्मैट में एक्सपोर्ट किया और आउटपुट को dot_data बफ़र में लिखा।

• dot_data बफ़र में संग्रहीत डिसीज़न ट्री के dot फ़ॉर्मैट प्रतिनिधित्व से एक pydotplus ग्राफ़ ऑब्जेक्ट बनाया।

• बने हुए ग्राफ़ को "diabetes.png" नामक PNG फ़ाइल में लिखा।

• IPython.display मॉड्यूल के Image ऑब्जेक्ट का उपयोग करके डिसीज़न ट्री की बनी PNG इमेज प्रदर्शित की।

जैसा कि आप देख सकते हैं, यह प्रून किया गया मॉडल कम जटिल, अधिक व्याख्यात्मक और पिछले डिसीज़न ट्री मॉडल प्लॉट की तुलना में समझने में आसान है।

डिसीज़न ट्री के फायदे और नुकसान

अब जब आपने एक डिसीज़न ट्री क्लासिफायर बनाया और ऑप्टिमाइज़ किया है, तो चलिए सामान्य रूप से एल्गोरिद्म की कुछ ताकतों और सीमाओं का मूल्यांकन करते हैं। ट्रेड-ऑफ समझना यह तय करने में मदद करता है कि कब डिसीज़न ट्री सही विकल्प हैं।

ध्यान दें कि कुछ नुकसान, जैसे वैरिएंस अस्थिरता, एंसेंबल विधियों जैसे बैगिंग और बूस्टिंग एल्गोरिद्म के माध्यम से कम किए जा सकते हैं।

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

हालाँकि हमने इस ट्यूटोरियल में पूरे डिसीज़न ट्री के साथ काम किया है, एक सरल वैरिएंट जिसे डिसीज़न स्टंप कहते हैं, समझना उपयोगी है। डिसीज़न स्टंप मूलतः एक ऐसा डिसीज़न ट्री है जिसकी अधिकतम गहराई एक होती है—अर्थात रूट नोड पर केवल एक स्प्लिट और दो लीफ नोड होते हैं।

डिसीज़न स्टंप उनकी सरलता के कारण शायद ही कभी स्टैंडअलोन क्लासिफायर के रूप में उपयोग किए जाते हैं। लेकिन वे एंसेंबल विधियों में भूमिका निभा सकते हैं, विशेष रूप से AdaBoost में डिसीज़न स्टंप को कमजोर लर्नर के रूप में जोड़ा जाता है ताकि एक मजबूत क्लासिफायर बनाया जा सके, या ग्रेडिएंट बूस्टिंग में क्योंकि स्टंप को बूस्टिंग प्रक्रिया में बेस लर्नर के रूप में उपयोग किया जा सकता है।

आप Scikit-learn में max_depth=1 सेट करके आसानी से एक डिसीज़न स्टंप बना सकते हैं:

# Create a Decision Stump
stump = DecisionTreeClassifier(max_depth=1)
stump = stump.fit(X_train, y_train)

निष्कर्ष

बधाई हो, आप इस ट्यूटोरियल के अंत तक पहुँच गए हैं!

इस ट्यूटोरियल में, आपने डिसीज़न ट्री के बारे में कई विवरण सीखे; यह कैसे काम करता है, एट्रिब्यूट सेलेक्शन मेजर्स जैसे Information Gain, Gain Ratio, और Gini Index, डिसीज़न ट्री मॉडल बनाना, विज़ुअलाइज़ेशन, और Python के Scikit-learn पैकेज का उपयोग करके डायबिटीज़ डेटासेट का मूल्यांकन। हमने इसके फायदे, नुकसान, और पैरामीटर ट्यूनिंग का उपयोग करके डिसीज़न ट्री प्रदर्शन को कैसे ऑप्टिमाइज़ करें, इस पर भी चर्चा की।

उम्मीद है, अब आप अपने स्वयं के डेटासेट का विश्लेषण करने के लिए डिसीज़न ट्री एल्गोरिद्म का उपयोग कर सकते हैं।

यदि आप Python में मशीन लर्निंग के बारे में और सीखना चाहते हैं, तो हमारा Machine Learning with Tree-Based Models in Python कोर्स करें। साथ ही हमारा Kaggle Tutorial: Your First Machine Learning Model भी देखें।