पढ्न मिल्ने निर्णय रुख · मेसिन लर्निङ, हातमा

निर्णय रुख भनेको कागजमा कोर्न मिल्ने मोडेल हो। यसले इनपुटबारे हो/होइन प्रश्नको शृङ्खला सोध्छ — के loan_to_income_ratio 2.5 भन्दा माथि छ? के जिल्ला कर्णाली हो? — र उत्तरहरूलाई शाखा बाटो तल पछ्याउँदै जान्छ जबसम्म पातमा पुगेर लेबल पूर्वानुमान गर्दैन। संरचना सहज छ: यसरी विचारशील मानिसले साथीलाई निर्णय व्याख्या गर्थ्यो। र मोडेल आफै यसको रुख भएकाले, तपाईं रुख प्रिन्ट गर्न, नियम पढ्न, र चुनौती दिन सक्नुहुन्छ — जसले निर्णय रुखलाई मेसिन लर्निङका सबैभन्दा व्याख्यायोग्य मोडेलमध्ये एक बनाउँछ।

आकार, कोरिएको

रुख कल्पना गर्नुहोस्। शिरमा जरा छ, एउटा प्रश्न सोध्दै:

                  loan_to_income_ratio > 2.5 ?
                         /             \
                       no                yes
                       /                   \
              monthly_income > 15000     district = Karnali?
                  /        \                 /          \
                yes         no              no           yes
                |           |               |            |
            no-default   no-default     default       default

हरेक गैर-पात नोडले प्रश्न सोध्छ। हरेक पातले लेबल असाइन गर्छ। नयाँ ऋणका लागि पूर्वानुमान गर्न, जराबाट सुरु गर्नुहोस्, प्रश्नको उत्तर दिनुहोस्, उपयुक्त शाखा पछ्याउनुहोस्, पातमा पुगुन्जेल दोहोर्‍याउनुहोस्, र त्यो पातको लेबल रिपोर्ट गर्नुहोस्।

निर्णय रुखका लागि तालिम प्रक्रिया: डाटालाई दुई समूहमा राम्रोसँग बाँड्ने प्रश्न छान्नुहोस् (एक तर्फ सबैभन्दा बढी “नो-डिफल्ट”, अर्को तर्फ सबैभन्दा बढी “डिफल्ट”), प्रत्येक तर्फ पुनरावृत्ति गर्नुहोस्, जब समूह शुद्ध हुन्छन् (एक लेबलले हावी गर्छ) वा जब रुख धेरै गहिरो हुन्छ तब रोक्नुहोस्।

ऋण डाटामा रुख तालिम

पहिले जस्तै उही pipeline ढाँचा:

from sklearn.tree import DecisionTreeClassifier
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

numeric = ["loan_amount", "monthly_income", "loan_to_income_ratio"]
categorical = ["district"]

model = Pipeline([
    ("preprocess", ColumnTransformer([
        ("num", "passthrough", numeric),   # रुखलाई स्केलिङ चाहिँदैन
        ("cat", OneHotEncoder(handle_unknown="ignore"), categorical),
    ])),
    ("classifier", DecisionTreeClassifier(max_depth=5, random_state=42)),
])

model.fit(X_train, y_train)
predictions = model.predict(X_test)

दुई ध्यान दिने कुरा:

सङ्ख्यात्मक फिचरका लागि "passthrough"। निर्णय रुखले मानहरूलाई सिधै तुलना गर्छ — के X > 2.5? — त्यसैले तिनलाई स्केल गर्नुले केही थप्दैन। रुख k-NN लाई सताउने स्केल समस्याप्रति इम्युन छन्। यो रुखको व्यवहारिक फाइदा हो।
max_depth=5। निर्णय रुखमा सबैभन्दा महत्त्वपूर्ण नब। यसबिना, रुख हरेक पात शुद्ध नभएसम्म बढ्छ, जसको अर्थ यसले तालिम डाटा कण्ठ गर्छ (overfit)। यससँग, रुख गहिरो हुँदैन र राम्रोसँग सामान्यीकरण गर्छ। अध्याय 4 यहाँ फर्किन्छ।

रुख पढ्ने

scikit-learn ले तपाईंलाई रुख सादा पाठमा प्रिन्ट गर्न दिन्छ:

from sklearn.tree import export_text

classifier = model.named_steps["classifier"]
preprocess = model.named_steps["preprocess"]
feature_names = preprocess.get_feature_names_out()

tree_text = export_text(classifier, feature_names=list(feature_names))
print(tree_text)

आउटपुट (काटिएको):

|--- num__loan_to_income_ratio <= 2.45
|   |--- num__monthly_income <= 14500.00
|   |   |--- num__loan_amount <= 25000.00
|   |   |   |--- class: 0
|   |   |--- num__loan_amount > 25000.00
|   |   |   |--- class: 1
|   |--- num__monthly_income > 14500.00
|   |   |--- class: 0
|--- num__loan_to_income_ratio > 2.45
|   |--- cat__district_Karnali <= 0.50
|   |   |--- class: 1
|   |--- cat__district_Karnali > 0.50
|   |   |--- class: 1

यो पढ्नुहोस्। मोडेलले तपाईंलाई, सरल नियममा भनिरहेको छ: यदि loan-to-income ratio उच्च छ भने, डिफल्ट पूर्वानुमान गर्नुहोस्। यदि यो मध्यम छ तर आय कम र ऋण ठूलो छ भने, पनि डिफल्ट पूर्वानुमान गर्नुहोस्। अन्यथा नो-डिफल्ट पूर्वानुमान गर्नुहोस्। तपाईंले यो नियम सेट माइक्रोफाइनान्स अधिकारीलाई पढाउन सक्नुहुन्छ र तिनले यसलाई उचित heuristic का रूपमा चिन्नेछन्। मोडेल कालो बक्स होइन — यो एल्गोरिथमले तपाईंका लागि लेखेको सानो नियम-पुस्तक हो।

Key idea

निर्णय रुख पढ्नु classical ML का सबैभन्दा सन्तुष्ट अनुभवमध्ये एक हो। मोडेलको तर्क दृश्य छ। तपाईं नियामक, सहकर्मी, वा ऋणीलाई सरल भाषामा पूर्वानुमान व्याख्या गर्न सक्नुहुन्छ: “तपाईंको ऋण फ्ल्याग भयो किनभने तपाईंको loan-to-income ratio 3.1 छ, जुन हाम्रो 2.45 को थ्रेसहोल्डभन्दा माथि छ।” यो व्याख्यायोग्यता महत्त्वपूर्ण छ जब मोडेलले वास्तविक मानिसहरूको बारेमा निर्णय लिन्छ।

सानो रुख देखाउने

साना रुख (गहिराइ 3 वा 4) का लागि, तपाईं तिनलाई चित्रका रूपमा प्रस्तुत गर्न सक्नुहुन्छ:

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree

fig, ax = plt.subplots(figsize=(16, 8))
plot_tree(
    classifier,
    feature_names=list(feature_names),
    class_names=["no-default", "default"],
    filled=True,
    rounded=True,
    fontsize=10,
)
plt.show()

नतिजा हरेक विभाजन लेबल गरिएको रङ-कोडेड रुख हो। गहिरा रुख भएका वास्तविक परियोजनाका लागि यो असम्हालिने हुन्छ, तर max_depth=3 वा max_depth=4 का लागि यसले स्लाइडमा टाँस्न लायक सुन्दर सारांश उत्पादन गर्छ।

`max_depth` ले के गर्छ — केन्द्रीय नब

max_depth (वा धेरै ठूलो) बिनाको निर्णय रुख हरेक पात शुद्ध नभएसम्म बढ्छ। 12,000 तालिम उदाहरणमा, यसले हजारौं पातसहितको रुख उत्पादन गर्न सक्छ, प्रत्येकले फिचर-स्पेसका साना कुनाहरू काट्दै। तालिम शुद्धता 100% नजिक हुनेछ। परीक्षण शुद्धता धेरै कम हुनेछ, किनभने रुखले शोर कण्ठ गरेको छ।

गहिरो रुख (max_depth=3, max_depth=5) ले सरल नियम बाध्य पार्छ। केही तालिम बिन्दु गलत वर्गीकरण हुन्छन् — र यो ठीक छ, किनभने नियम सामान्यीकरण गर्छन्।

धेरै मान कोसिस गर्नुहोस् र हेर्नुहोस् के हुन्छ:

for depth in [3, 5, 10, 20, None]:
    model = make_tree_pipeline(max_depth=depth)
    model.fit(X_train, y_train)
    train_acc = model.score(X_train, y_train)
    test_acc = model.score(X_test, y_test)
    print(f"depth={depth}: train={train_acc:.3f}  test={test_acc:.3f}")

तपाईंले यस्तै देख्नुहुनेछ:

depth=3:    train=0.834  test=0.821
depth=5:    train=0.847  test=0.831
depth=10:   train=0.902  test=0.819
depth=20:   train=0.987  test=0.762
depth=None: train=1.000  test=0.731

यहाँ गहिराइ 5 मीठो ठाउँ हो — सामान्यीकरण गर्न पर्याप्त सानो, वास्तविक संरचना पक्रन पर्याप्त ठूलो। त्यसभन्दा पर, तालिम शुद्धता चढ्दै जान्छ जबकि परीक्षण शुद्धता झर्छ। यो overfitting हो, र अध्याय 4 ले औपचारिक रूपमा नाम दिनेछ।

रुख एक्लै बनाम रुख भवन ब्लकका रूपमा

एकल निर्णय रुख उचित छ। यो एक्लै विरलै सर्वोत्तम मोडेल हुन्छ, किनभने व्यक्तिगत रुख भङ्गुर हुन सक्छन् — एक थ्रेसहोल्ड सर्दा पूर्वानुमान बदलिन्छ। रुखको वास्तविक शक्ति जब तपाईं तिनको धेरै संयोजन गर्नुहुन्छ तब आउँछ।

रुखबाट बनेका दुई सबैभन्दा बलियो classical ML मोडेल:

Random forests। डाटाका फरक अनियमित नमुनामा सयौं रुख तालिम दिनुहोस्, हरेक विभाजनले फिचरको अनियमित उपसमूह मात्र विचार गर्दै। तिनका मत औसत गर्नुहोस्।
Gradient boosting (XGBoost, LightGBM, scikit-learn को GradientBoostingClassifier)। रुखलाई क्रमिक रूपमा तालिम दिनुहोस्, हरेक नयाँ रुखले अघिल्लोका त्रुटि सुधार्दै।

दुवै अध्याय 5 मा छन्। अहिलेलाई, दिमागमा राख्नुहोस्: तपाईंले भर्खर सिकेको निर्णय रुख ती धेरै बढी शक्तिशाली मोडेलहरूको भवन ब्लक हो। सरललाई मास्टर गर्दा तपाईंले आकर्षकहरूलाई झन्डै निःशुल्क कमाउनुहुन्छ।

आफ्नो बुझाइ जाँच्नुहोस्

Quick check

—

एक टिम सदस्यले max_depth नराखी निर्णय रुख तालिम दिन्छन् र 99.8% तालिम शुद्धता रिपोर्ट गर्छन्। तिनी तैनात गर्न लाग्दैछन्। चेतावनी सङ्केत के हो?

99.8% उत्कृष्ट छ; तैनात गर्नुहोस्।
max_depth बिना, रुख झन्डै हरेक पात शुद्ध नहुँदासम्म बढ्छ, जसको अर्थ रुखले तालिम डाटा र यसको शोर सहित कण्ठ गरेको छ। 99.8% तालिम शुद्धता त्यसैले सीपको मापन होइन; यो कण्ठको मापन हो। परीक्षण शुद्धता लगभग निश्चित रूपमा धेरै कम हुनेछ — मोडेल overfitting हुँदैछ। max_depth सेट गर्नुहोस् (अधिकांश समस्याका लागि 5 देखि 10), वा प्रदर्शन रिपोर्ट गर्नुअघि गहिराइ छान्न cross-validation प्रयोग गर्नुहोस्।
निर्णय रुख कुनै पनि गहिराइमा सधैं overfit हुन्छन्; k-NN मा सर्नुहोस्।
तैनाती अघि तालिम डाटा दस गुणा बढाउनुहोस्।