Machine Learning Academy · पाठ

Gini अशुद्धता और सूचना लाभ

शिक्षार्थी नमूना विभाजनों के लिए Gini अशुद्धता और एन्ट्रॉपी की गणना करेंगे तथा समझेंगे कि ट्री सूचना लाभ को अधिकतम करने वाला विभाजन क्यों चुनता है।

पाठ 2, कुल 4 में से13 चरण

Gini अशुद्धता और सूचना लाभ, CoddyKit पर Machine Learning Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Machine Learning Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

विभाजन की समस्या: किस फ़ीचर के बारे में पूछें?

निर्णय वृक्ष बनाते समय, प्रत्येक नोड पर हमें यह चुनना होता है कि कौन सा फ़ीचर और कौन सी सीमा सबसे उपयोगी विभाजन बनाएगी। लक्ष्य ऐसे child nodes बनाना है जिनमें नमूने अधिकतम शुद्ध हों — आदर्श रूप से प्रत्येक child में केवल एक वर्ग हो। हमें अशुद्धता का एक गणितीय माप चाहिए, जो बताए कि किसी नोड में वर्ग कितने मिश्रित हैं। कम अशुद्धता बेहतर होती है: एक ही वर्ग के सभी नमूनों वाले नोड की अशुद्धता शून्य होती है (पूर्ण शुद्धता)। व्यापक रूप से उपयोग किए जाने वाले दो अशुद्धता माप हैं: Gini अशुद्धता और entropy।

# Impurity measures how mixed the classes are in a node
# Perfect purity: all samples belong to one class -> impurity = 0
# Maximum impurity: classes are equally distributed

import numpy as np

# Node A: all class 0 -> pure
node_a = [0, 0, 0, 0]  # impurity = 0

# Node B: 50/50 mix -> maximally impure
node_b = [0, 0, 1, 1]  # impurity = maximum

# Node C: mostly one class
node_c = [0, 0, 0, 1]  # impurity = low

for name, node in [('A', node_a), ('B', node_b), ('C', node_c)]:
    print(f'Node {name}: classes = {node}')

Gini अशुद्धता: डिफ़ॉल्ट criterion

Gini अशुद्धता यह मापती है कि किसी नोड से यादृच्छिक रूप से चुने गए नमूने को, उस नोड के वर्ग-वितरण के अनुसार यादृच्छिक रूप से label करने पर, गलत label मिलने की प्रायिकता कितनी है। सूत्र है: Gini = 1 - sum(p_i^2), जहाँ p_i वर्ग i का अनुपात है। Gini का मान 0 (शुद्ध) से 0.5 (दो वर्गों का समान विभाजन) तक होता है। K वर्गों के लिए अधिकतम मान 1 - 1/K होता है। स्किकिट-लर्न के DecisionTreeClassifier में Gini अशुद्धता डिफ़ॉल्ट criterion है, क्योंकि यह computationally efficient है (लघुगणक की आवश्यकता नहीं होती)।

import numpy as np

def gini_impurity(y):
    classes, counts = np.unique(y, return_counts=True)
    probabilities = counts / len(y)
    return 1 - np.sum(probabilities ** 2)

# Pure node
print('Pure [0,0,0,0]:', gini_impurity([0,0,0,0]))       # 0.0

# 50/50 split
print('50/50 [0,0,1,1]:', gini_impurity([0,0,1,1]))      # 0.5

# 75/25 split
print('75/25 [0,0,0,1]:', gini_impurity([0,0,0,1]))      # 0.375

# Three classes equal
print('3-class equal:', gini_impurity([0,1,2,0,1,2]))    # ~0.667

Entropy और सूचना सिद्धांत

entropy सूचना सिद्धांत से लिया गया विचार है: यह किसी वितरण की अनिश्चितता या सूचना-सामग्री को मापता है। सूत्र: H = -sum(p_i * log2(p_i))। शुद्ध नोड की entropy 0 होती है (कोई अनिश्चितता नहीं)। 50/50 विभाजन की entropy 1 होती है (एक bit की अनिश्चितता — वर्ग निर्धारित करने के लिए आपको एक प्रश्न चाहिए)। व्यवहार में entropy और Gini लगभग समान वृक्ष बनाते हैं। entropy की गणना थोड़ी धीमी होती है (इसमें log की आवश्यकता होती है), लेकिन वर्ग-वितरण असंतुलित होने पर यह बेहतर विभाजन दे सकती है। बदलने के लिए स्किकिट-लर्न में criterion='entropy' का उपयोग करें।

import numpy as np

def entropy(y):
    classes, counts = np.unique(y, return_counts=True)
    probabilities = counts / len(y)
    # Avoid log(0) by filtering zero probabilities
    probs = probabilities[probabilities > 0]
    return -np.sum(probs * np.log2(probs))

print('Pure [0,0,0,0]:', entropy([0,0,0,0]))         # 0.0
print('50/50 [0,0,1,1]:', entropy([0,0,1,1]))        # 1.0 (1 bit)
print('75/25 [0,0,0,1]:', entropy([0,0,0,1]).round(3))  # 0.811
print('3-class equal:', entropy([0,1,2,0,1,2]).round(3)) # 1.585

Information_gain: विभाजन की गुणवत्ता का माप

information_gain यह मापता है कि कोई विभाजन अशुद्धता को कितना कम करता है। इसकी गणना parent node की अशुद्धता में से child nodes की भारित औसत अशुद्धता घटाकर की जाती है: IG = impurity(parent) - (N_left/N * impurity(left) + N_right/N * impurity(right))। सबसे अच्छा विभाजन information_gain को अधिकतम करता है: यह ऐसे children बनाता है जो आकार के अनुसार भारित होकर अधिकतम शुद्ध हों (इसलिए बड़े children का योगदान अधिक होता है)। वृक्ष निर्माता प्रत्येक फ़ीचर और प्रत्येक सीमा के लिए information_gain का मूल्यांकन करता है, फिर सबसे अधिक gain वाला संयोजन चुनता है।

import numpy as np

def gini_impurity(y):
    _, counts = np.unique(y, return_counts=True)
    p = counts / len(y)
    return 1 - np.sum(p**2)

def information_gain(y_parent, y_left, y_right):
    n = len(y_parent)
    n_l, n_r = len(y_left), len(y_right)
    parent_impurity = gini_impurity(y_parent)
    weighted_child  = (n_l/n)*gini_impurity(y_left) + (n_r/n)*gini_impurity(y_right)
    return parent_impurity - weighted_child

y_parent = [0,0,0,1,1,1]  # 50/50 parent
y_left   = [0,0,0]         # pure left
y_right  = [1,1,1]         # pure right

print('IG:', information_gain(y_parent, y_left, y_right))  # 0.5 (perfect split)

कई विभाजनों का मूल्यांकन

सबसे अच्छा विभाजन खोजने के लिए एल्गोरिदम सभी संभावित फ़ीचर-सीमा संयोजनों का मूल्यांकन करता है और सबसे अधिक information_gain वाला संयोजन चुनता है। N नमूनों और d फ़ीचर वाले डेटासेट के लिए, वृक्ष प्रत्येक फ़ीचर पर अधिकतम N-1 सीमाओं का मूल्यांकन करता है (लगातार unique मानों के बीच के मध्यबिंदु), इसलिए प्रत्येक नोड पर मूल्यांकन किए जाने वाले विभाजनों की संख्या O(N * d) तक होती है। यहाँ एक सरल उदाहरण दिया गया है, जो दिखाता है कि एक ही फ़ीचर पर अलग-अलग सीमाएँ अलग-अलग information gains कैसे उत्पन्न करती हैं।

import numpy as np

X_feature = np.array([1, 2, 3, 4, 5, 6])
y = np.array([0, 0, 0, 1, 1, 1])

best_threshold, best_ig = None, -1

for threshold in [1.5, 2.5, 3.5, 4.5, 5.5]:
    left_mask  = X_feature <= threshold
    right_mask = ~left_mask
    y_l, y_r = y[left_mask], y[right_mask]
    
    _, cnt_p = np.unique(y, return_counts=True)
    _, cnt_l = np.unique(y_l, return_counts=True) if len(y_l) else (None, [1])
    _, cnt_r = np.unique(y_r, return_counts=True) if len(y_r) else (None, [1])
    
    ig = information_gain(y, y_l, y_r)
    print(f'Threshold {threshold}: IG = {ig:.3f}')
    if ig > best_ig:
        best_ig, best_threshold = ig, threshold

print('Best threshold:', best_threshold, 'with IG:', best_ig)

Gini बनाम Entropy: व्यावहारिक अंतर

Gini अशुद्धता और entropy अधिकांश समय लगभग समान वृक्ष बनाते हैं। मुख्य अंतर सूक्ष्म हैं: entropy अधिक संतुलित वृक्ष बनाने की प्रवृत्ति रखती है (लघुगणक के कारण यह असंतुलित विभाजनों को अधिक दंड देती है), जबकि Gini सबसे अधिक बार आने वाले वर्ग को एक शाखा में अलग करने की प्रवृत्ति रखती है। computationally, Gini तेज़ है क्योंकि इसमें लघुगणक की गणना नहीं करनी पड़ती। व्यवहार में इनके बीच चयन tune किया जाने वाला hyperparameter है — cross-validation के साथ दोनों आज़माएँ और अपने विशिष्ट डेटासेट पर बेहतर प्रदर्शन करने वाला चुनें।

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

for criterion in ['gini', 'entropy']:
    tree = DecisionTreeClassifier(criterion=criterion, max_depth=5, random_state=42)
    score = cross_val_score(tree, X, y, cv=10).mean()
    print(f'criterion={criterion}: CV accuracy = {score:.3f}')

# Usually within 0.5% of each other -- not the critical choice

बहु-वर्ग समस्याओं के लिए भारित Gini

Gini अशुद्धता बिना किसी संशोधन के स्वाभाविक रूप से बहु-वर्ग समस्याओं तक विस्तारित होती है: Gini = 1 - sum(p_i^2) किसी भी संख्या में वर्गों के लिए काम करता है। information_gain की गणना भी अपरिवर्तित रहती है — children की भारित अशुद्धता में से parent की अशुद्धता घटाई जाती है। 3-वर्ग वाली समस्या में पूरी तरह शुद्ध लीफ़ (उदाहरण के लिए, सभी नमूने वर्ग 2 के) का Gini 0 होता है। 3 वर्गों के समान अनुपात वाले नोड का अधिकतम Gini 2/3 होता है। निर्णय वृक्ष उन कुछ एल्गोरिदम में से हैं जो बहु-वर्ग समस्याओं को बिना किसी संशोधन के मूल रूप से संभालते हैं — logistic regression के विपरीत, जिसमें one-vs-rest या softmax विस्तार आवश्यक होते हैं।

import numpy as np

def gini_multiclass(y):
    _, counts = np.unique(y, return_counts=True)
    p = counts / len(y)
    return 1 - np.sum(p**2)

# 3-class examples
print('Pure [0,0,0]:', gini_multiclass([0,0,0]))               # 0.0
print('Equal [0,1,2]:', gini_multiclass([0,1,2]).round(3))    # 0.667
print('2 dominant [0,0,1,2]:', gini_multiclass([0,0,1,2]).round(3))  # 0.625

# Max Gini for K classes = 1 - 1/K
for K in [2, 3, 4, 5]:
    print(f'Max Gini for {K} classes: {1 - 1/K:.3f}')

स्किकिट-लर्न के भीतर अशुद्धता में कमी

स्किकिट-लर्न के भीतर, प्रत्येक नोड पर वृक्ष विभाजन से पहले की अशुद्धता और प्रत्येक child की अशुद्धता संग्रहीत करता है। नमूनों की संख्या के आधार पर भारित इन दोनों का अंतर अशुद्धता में कमी (information_gain) होता है। इस मान को सभी नोड पर प्रत्येक फ़ीचर के लिए जोड़ा जाता है और feature_importances_ निकालने के लिए सामान्यीकृत किया जाता है — यानी प्रत्येक फ़ीचर से संबंधित कुल अशुद्धता में कमी। जो फ़ीचर रूट के पास दिखाई देते हैं और कई नमूनों को संभालते हैं, उनका महत्व अधिक होने की प्रवृत्ति रखता है, क्योंकि प्रत्येक विभाजन डेटा के बड़े अंश को प्रभावित करता है।

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np

X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42)
tree.fit(X, y)

# Impurity at root and children
print('Root impurity (Gini):', tree.tree_.impurity[0].round(4))
print('Left child impurity:', tree.tree_.impurity[1].round(4))
print('Right child impurity:', tree.tree_.impurity[2].round(4))

# Feature importances = total weighted impurity reduction per feature
print('Feature importances:', tree.feature_importances_.round(3))

min_impurity_decrease की भूमिका

डिफ़ॉल्ट रूप से, ट्री नोड्स को तब तक विभाजित करता है, जब तक अशुद्धता में कोई भी कमी आती हो और नोड में पर्याप्त नमूने हों। min_impurity_decrease पैरामीटर एक न्यूनतम सीमा जोड़ता है: विभाजन तभी बनाया जाता है, जब वह अशुद्धता को कम-से-कम इस मात्रा तक घटाए। इससे ट्री ऐसे बहुत छोटे विभाजन बनाने से बचता है, जो शोर को याद कर लेते हैं। min_impurity_decrease=0.01 सेट करने का अर्थ है कि ट्री तभी विभाजित होगा, जब information_gain 0.01 से अधिक हो। यह गहराई को सीधे नियंत्रित करने के विकल्प के रूप में नियमितीकरण का एक उपयोगी तरीका है।

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

for min_ig in [0.0, 0.001, 0.005, 0.01, 0.05]:
    tree = DecisionTreeClassifier(
        min_impurity_decrease=min_ig,
        random_state=42
    )
    score = cross_val_score(tree, X, y, cv=5).mean()
    depth = tree.fit(X, y).get_depth()
    print(f'min_impurity_decrease={min_ig}: depth={depth}, CV acc={score:.3f}')

विशेषताओं में विभाजनों की तुलना

यह उदाहरण दिखाता है कि ट्री सबसे अच्छी विशेषता और सीमा कैसे चुनता है। दो विशेषताओं और प्रत्येक के लिए एक विभाजन सीमा दिए जाने पर, ट्री सभी विकल्पों के लिए information_gain की गणना करता है और विजेता विकल्प चुनता है। इससे स्पष्ट होता है कि ट्री स्वाभाविक रूप से निहित विशेषता चयन करते हैं: जो विशेषताएँ किसी भी सीमा पर अधिक information_gain उत्पन्न नहीं करतीं, उन्हें विभाजन की विशेषताओं के रूप में कभी नहीं चुना जाता और प्रभावी रूप से अनदेखा कर दिया जाता है। इसी कारण निर्णय ट्री अप्रासंगिक विशेषताओं के प्रति मजबूत होते हैं, जबकि KNN उनसे प्रभावित होता है।

import numpy as np

# Toy dataset: X[:,0]=income, X[:,1]=age; y=churn
X = np.array([[100, 25], [120, 30], [40, 22], [50, 28], [90, 35], [30, 40]])
y = np.array([0, 0, 1, 1, 0, 1])

# Try splitting on income at 75
left_y = y[X[:, 0] <= 75]   # [1,1,1]
right_y = y[X[:, 0] > 75]   # [0,0,0]
ig_income = information_gain(y, left_y, right_y)

# Try splitting on age at 30
left_y2 = y[X[:, 1] <= 30]  # [0,0,1,1]
right_y2 = y[X[:, 1] > 30]  # [0,1]
ig_age = information_gain(y, left_y2, right_y2)

print(f'IG(income<=75): {ig_income:.3f}')
print(f'IG(age<=30):    {ig_age:.3f}')
print('Best split:', 'income' if ig_income > ig_age else 'age')

GridSearchCV में जिनी का उपयोग

Decision tree को समायोजित करते समय, आप पैरामीटर ग्रिड में criterion पैरामीटर (जिनी बनाम एंट्रॉपी) शामिल कर सकते हैं, ताकि cross-validation आपके विशेष डेटासेट के लिए बेहतर विकल्प चुन सके। इसी खोज में max_depth, min_samples_split, और min_samples_leaf को भी शामिल करें। criterion पर खोज करने में बहुत कम अतिरिक्त गणनात्मक लागत आती है — प्रत्येक संयोजन के लिए केवल दो अतिरिक्त विन्यास — और जब वर्गों का वितरण बहुत असंतुलित हो या डेटासेट में समान गुणवत्ता वाले कई विभाजन हों, तब कभी-कभी इससे उल्लेखनीय सुधार मिलता है।

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

param_grid = {
    'criterion': ['gini', 'entropy'],
    'max_depth': [3, 5, 7, None],
    'min_samples_leaf': [1, 5, 10]
}

grid = GridSearchCV(
    DecisionTreeClassifier(random_state=42),
    param_grid, cv=10, scoring='accuracy', n_jobs=-1
)
grid.fit(X, y)

print('Best criterion:', grid.best_params_['criterion'])
print('Best depth:', grid.best_params_['max_depth'])
print('Best CV accuracy:', grid.best_score_.round(4))

त्वरित जाँच

इस पाठ में दिए गए Python के साथ Machine Learning संबंधी सिद्धांतों की अपनी समझ जाँचें।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने सीखा: जिनी अशुद्धता यह मापती है कि किसी नोड में वर्ग कितने मिश्रित हैं (सूत्र: 1 - sum(p_i^2)), information_gain यह मापता है कि कोई विभाजन अशुद्धता को कितना कम करता है (जनक अशुद्धता में से भारित संतति अशुद्धता घटाने पर), और ट्री सभी विशेषताओं तथा सीमाओं में से हमेशा वह विभाजन चुनता है जो information_gain को अधिकतम करता है। अब हम अति-अनुरूपण से बचने के लिए ट्री की गहराई को नियंत्रित करना सीखेंगे।

शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 30
पाठ: 120

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “Gini अशुद्धता और सूचना लाभ” पाठ निःशुल्क है?

हाँ—“Gini अशुद्धता और सूचना लाभ” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Machine Learning Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Machine Learning Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“Gini अशुद्धता और सूचना लाभ” में मैं क्या सीखूँगा?

शिक्षार्थी नमूना विभाजनों के लिए Gini अशुद्धता और एन्ट्रॉपी की गणना करेंगे तथा समझेंगे कि ट्री सूचना लाभ को अधिकतम करने वाला विभाजन क्यों चुनता है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Machine Learning Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Machine Learning Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Machine Learning Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“Gini अशुद्धता और सूचना लाभ” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Machine Learning Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Machine Learning Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

ट्री बनाना: विभाजन, नोड और लीफ़
Gini अशुद्धता और सूचना लाभ
अधिक-फिटिंग रोकने के लिए ट्री की गहराई नियंत्रित करना
निर्णय ट्री का दृश्यांकन और व्याख्या

← Machine Learning Academy पर वापस जाएँ