तपाईंको पहिलो वर्गीकरणकर्ता, सुरुदेखि अन्त्यसम्म

योजना

छ चरण। हरेकमा एक वा दुई लाइन कोड:

1. सफा डाटासेट लोड गर्नुहोस्।
2. फिचर र लक्ष्य स्तम्भ छान्नुहोस्।
3. तालिम र परीक्षणमा बाँड्नुहोस्।
4. सङ्ख्यात्मक फिचर स्केल गर्नुहोस्।
5. लोजिस्टिक रिग्रेसन तालिम दिनुहोस्।
6. राखिएको परीक्षण सेटमा मूल्याङ्कन गर्नुहोस्, र भार पढ्नुहोस्।

आफ्नो building-ai-notes/ml-first-classifier/ फोल्डरमा नयाँ नोटबुक खोल्नुहोस्। Course 01 को सक्रिय वातावरणमा pip install scikit-learn pandas गरेको सुनिश्चित गर्नुहोस्।

चरण 1 — लोड

import pandas as pd

df = pd.read_csv("data/clean/loans.csv")
print(df.shape)
print(df.head())

तपाईंले 12,847 पङ्क्ति × 8 स्तम्भ (वा तपाईंको सफा गरिएको डाटासेटमा जे छ त्यो) देख्नुपर्छ। तपाईंसँग के स्तम्भ छन् सम्झन .head() हेर्नुहोस्। हामी loan_amount, monthly_income, district, occupation_category, defaulted, र केही इन्जिनियर गरिएका फिचर जस्तै केही अपेक्षा गर्छौँ।

चरण 2 — फिचर र लक्ष्य छान्ने

पहिलो वर्गीकरणकर्ताका लागि, सानै राख्नुहोस्। तीन फिचर:

numeric_features = ["loan_amount", "monthly_income"]
categorical_features = ["district"]
target = "defaulted"

# Course 02 अध्याय 5 बाट इन्जिनियर गरिएको फिचरका रूपमा loan-to-income ratio गणना गर्नुहोस्
df["loan_to_income_ratio"] = df["loan_amount"] / df["monthly_income"]
numeric_features.append("loan_to_income_ratio")

X = df[numeric_features + categorical_features].copy()
y = df[target].copy()

# छुटेको लक्ष्य वा कुनै छुटेको फिचर भएका पङ्क्ति हटाउनुहोस् (अल्छी पहिलो-प्रहार; अध्याय 3 मा राम्रा रणनीति)
mask = X.notna().all(axis=1) & y.notna()
X, y = X[mask], y[mask]

print("Final shape:", X.shape, "Defaults:", y.sum(), "of", len(y))

उपयोगी sanity check: कति अनुपात ऋणले डिफल्ट गरे? यदि 5% छ भने, तपाईंसँग imbalanced समस्या छ (हामी अध्याय 4 मा त्यो सम्हाल्नेछौं)। यदि 30-50% छ भने, तपाईंसँग सन्तुलित समस्या छ। जे भए पनि, केही तालिम दिनुअघि उत्तर थाहा पाउनुहोस्।

चरण 3 — बाँड्ने

सिधै Course 02 अध्याय 5 बाट:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42,
)

print("Train:", X_train.shape, "Test:", X_test.shape)

stratify=y ले दुवै बाँडमा डिफल्ट-दर सुरक्षित गर्छ। random_state=42 ले बाँड पुन: उत्पादनयोग्य बनाउँछ।

चरण 4 — स्केल (र श्रेणीगत फिचर इन्कोड)

Course 02 अध्याय 5 जस्तै एउटा Pipeline सँगै ColumnTransformer। यसले स्केलिङ, इन्कोडिङ, र fit-on-train-only अनुशासन स्वचालित रूपमा सम्हाल्छ:

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder

preprocess = ColumnTransformer([
    ("num", StandardScaler(), numeric_features),
    ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
])

चरण 5 — तालिम

ठूलो क्षण। दुई लाइन:

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

model = Pipeline([
    ("preprocess", preprocess),
    ("classifier", LogisticRegression(max_iter=1000)),
])

model.fit(X_train, y_train)
print("Trained.")

त्यो .fit(X_train, y_train) नै पूर्ण तालिम प्रक्रिया हो: अप्टिमाइजर चल्छ, लोस घटाउँछ, मोडेलका नब आफ्नो ठाउँमा बस्छन्। यस्तो सानो डाटासेटमा, यसलाई सेकेन्डको एक अंश लाग्छ।

चरण 6 — मूल्याङ्कन र भार पढ्ने

पहिले, परीक्षण सेटमा पूर्वानुमान:

from sklearn.metrics import accuracy_score, classification_report

predictions = model.predict(X_test)
print("Test accuracy:", accuracy_score(y_test, predictions))
print()
print(classification_report(y_test, predictions))

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

Test accuracy: 0.83

              precision    recall  f1-score   support
       False       0.87      0.91      0.89      2031
        True       0.71      0.62      0.66       540

    accuracy                           0.83      2571
   macro avg       0.79      0.76      0.78      2571
weighted avg       0.83      0.83      0.83      2571

83% शुद्धता। अध्याय 4 ले तपाईंलाई सिकाउनेछ कि केवल शुद्धता भ्रामक छ — र precision, recall, र F1 राम्रोसँग व्याख्या गर्नेछ। अहिलेलाई, ध्यान दिनुहोस्: मोडेल “डिफल्ट नभएको” पूर्वानुमान गर्न (87% precision, 91% recall) “डिफल्ट भएको” (71% precision, 62% recall) भन्दा राम्रो छ। त्यो असमानता वास्तविक र महत्त्वपूर्ण छ। प्रश्न अध्याय 4 का लागि राख्नुहोस्।

अब भार पढ्नुहोस्:

import numpy as np

classifier = model.named_steps["classifier"]
preprocessor = model.named_steps["preprocess"]

# one-hot इन्कोडिङपछि फिचर नाम पाउनुहोस्
encoded_names = preprocessor.get_feature_names_out()

# गुणक
coefs = classifier.coef_[0]
for name, coef in sorted(zip(encoded_names, coefs), key=lambda x: abs(x[1]), reverse=True)[:10]:
    print(f"  {name:40s} {coef:+.3f}")

print(f"  {'intercept':40s} {classifier.intercept_[0]:+.3f}")

आउटपुट (चित्रात्मक):

  num__loan_to_income_ratio                +0.812
  num__monthly_income                      -0.394
  num__loan_amount                         +0.215
  cat__district_Karnali                    +0.184
  cat__district_Bagmati                    -0.122
  ...
  intercept                                -1.456

यो पढ्नुहोस्। मोडेलले सिक्यो कि:

• उच्च loan_to_income_ratio ले डिफल्टको पूर्वानुमानित सम्भावना बढाउँछ (+0.812 भार)। अपेक्षित र आश्वस्त पार्ने।
• उच्च monthly_income ले घटाउँछ (-0.394)। अपेक्षित।
• आयको नियन्त्रण गर्दा — उच्च loan_amount ले डिफल्ट जोखिम अलिकति बढाउँछ। समझदार।
• कर्णाली जिल्लाका ऋणले अलिकति उच्च पूर्वानुमानित डिफल्ट जोखिम राख्छन्; बागमतीको कम। यो वास्तविक सङ्केत हो कि तालिम डाटामा पूर्वाग्रहको कलाकृति हो छानबिन गर्न लायक (Course 02 अध्याय 6 सम्झनुहोस्)।

यो sklearn सँग काम गर्ने त्यो भाग हो जुन अभ्यासकर्ताहरूले सबैभन्दा बढी मन पराउँछन्। मोडेल कालो बक्स होइन: तपाईं यसले के सिक्यो पढ्न सक्नुहुन्छ। भार तपाईंको डाटाले मोडेललाई सुनाएको कथा हो। कुनै पनि कुरा तैनात गर्नुअघि कथा पढ्नु अनुशासनको भाग हो।

एक ठाउँमा पूरा स्क्रिप्ट

सन्दर्भका लागि, पूरै पाइपलाइन जोडिएको:

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score, classification_report


def main():
    df = pd.read_csv("data/clean/loans.csv")
    df["loan_to_income_ratio"] = df["loan_amount"] / df["monthly_income"]

    numeric = ["loan_amount", "monthly_income", "loan_to_income_ratio"]
    categorical = ["district"]
    X = df[numeric + categorical].copy()
    y = df["defaulted"].copy()

    mask = X.notna().all(axis=1) & y.notna()
    X, y = X[mask], y[mask]

    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, stratify=y, random_state=42,
    )

    model = Pipeline([
        ("preprocess", ColumnTransformer([
            ("num", StandardScaler(), numeric),
            ("cat", OneHotEncoder(handle_unknown="ignore"), categorical),
        ])),
        ("classifier", LogisticRegression(max_iter=1000)),
    ])

    model.fit(X_train, y_train)

    predictions = model.predict(X_test)
    print("Test accuracy:", accuracy_score(y_test, predictions))
    print(classification_report(y_test, predictions))


if __name__ == "__main__":
    main()

पचास भन्दा कम लाइन। चलाउनुहोस्। शुद्धता प्रिन्ट हुँदा हेर्नुहोस्। रिपोर्ट पढ्नुहोस्। तपाईंले अन्त-देखि-अन्त ML गर्नुभयो।

यो खण्डबाट के लिनुपर्छ

अघि लिन तीन कुरा:

1. आकार स्थायी छ। लोड, फिचर छान्ने, बाँड्ने, पूर्व-प्रशोधन, fit, मूल्याङ्कन, पढ्ने। यो पाठ्यक्रमको बाँकीका हरेक परियोजनाले यो लय पछ्याउँछ। मोडेल बदलिन्छन्। ढाँचा बदलिँदैन।

2. परीक्षण शुद्धता 83% सुरुवात बिन्दु हो। सन्दर्भबिना, यो केवल सङ्ख्या हो — यसले मोडेल उपयोगी छ कि छैन बताउँदैन। अध्याय 4 ले शुद्धताले किन झुटो बोल्न सक्छ, र precision/recall असमानतालाई सही रूपमा कसरी पढ्ने देखाउनेछ।

3. भार पढ्नु कामको भाग हो। तपाईंले व्याख्या गर्न नसक्ने गुणक भएको मोडेल तपाईंले तैनात गर्नु हुँदैन। सरल मोडेलका लागि, sklearn ले यो सजिलो बनाउँछ। पहुँच प्रयोग गर्नुहोस्।

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

Quick check

—

एक साथीले लेख्छिन्: preprocess = StandardScaler() preprocess.fit(X) # पूरै डाटासेटमा fit X_train, X_test = train_test_split(preprocess.transform(X), y) model.fit(X_train, y_train) यो किन गलत क्रम हो, र यो खण्डको Pipeline दृष्टिकोणले बरु के गर्छ?

1. Aक्रम ठीक छ — स्केलर सबै डाटामा फिट हुनुपर्छ ताकि यसले वास्तविक औसत र मानक विचलन सिक्छ।
2. Bयसले परीक्षण सेटबाट स्केलरका पारामिटर (औसत र std दुवै तालिम र परीक्षण पङ्क्तिमा गणना गरिन्छन्) मा जानकारी लीक गर्छ, त्यसैले परीक्षण सेटमा 'मूल्याङ्कन' आशावादी छ। Pipeline दृष्टिकोणले तपाईंले `model.fit(X_train, y_train)` कल गर्दा तालिम फोल्डमा मात्र स्केलर fit गर्छ, र तपाईंले `model.predict(X_test)` कल गर्दा उही तालिम-व्युत्पन्न स्केलिङ परीक्षण डाटामा स्वचालित रूपमा लागू गर्छ।
3. CStandardScaler लोजिस्टिक रिग्रेसनसँग असंगत छ; MinMaxScaler प्रयोग गर्नुहोस्।
4. DPipeline दृष्टिकोण ढिलो र कम शुद्ध हुन्छ।

Check answer→

Quick check

—

तपाईंको तालिम प्राप्त वर्गीकरणकर्ताले 95% परीक्षण शुद्धता देखाउँछ। तपाईं तैनात गर्न लाग्नुभएको छ। classification report ले 95% शुद्धता देखाउँछ किनभने डाटासेट 95% गैर-डिफल्टर र केवल 5% डिफल्टर छ, र मोडेलले झन्डै हरेक ऋणका लागि 'no default' पूर्वानुमान गर्छ। सही पढाइ के हो?

1. A95% शुद्धता उत्कृष्ट छ; तुरुन्तै तैनात गर्नुहोस्।
2. Bमोडेलले मूलतः सबैका लागि बहुसङ्ख्यक कक्षा पूर्वानुमान गर्दैछ। 95% शुद्धताले कक्षा असन्तुलन प्रतिबिम्बित गर्छ, वास्तविक सिकाइ होइन — सधैं 'no default' पूर्वानुमान गर्ने मोडेलले पनि 95% स्कोर गर्छ। तपाईंले अल्पसङ्ख्यक (default) कक्षाका लागि precision र recall विशेष रूपमा हेर्नुपर्छ, र सम्भवतः class_weight='balanced' सँग पुन: तालिम दिनुपर्छ वा निर्णय थ्रेसहोल्ड समायोजन गर्नुपर्छ। अध्याय 4 यस्तै अवस्थाको ध्यानवान् संस्करण हो।
3. Cतालिम पुनरावृत्ति सङ्ख्या बढाउनुहोस्।
4. Dमोडेल बिग्रिएको छ; कोड डिबग गर्नुहोस्।

Check answer→

अब के आउँछ

तपाईंले आफ्नो पहिलो वर्गीकरणकर्ता तालिम दिनुभयो, मूल्याङ्कन गर्नुभयो, र पढ्नुभयो। यो पाठ्यक्रमको बाँकी पूरै हरेक चरण तिख्याउने हो। अध्याय 2 ले दुई थप वर्गीकरणकर्ता — निकटतम छिमेकी र निर्णय रुख — र पूर्ण रूपमा कार्य गरिएको SMS-स्प्याम उदाहरण परिचय गराउँछ। अध्याय 3 ले रिग्रेसन (सङ्ख्या पूर्वानुमान) ओगट्छ। अध्याय 4 ले यो खण्डमा उठाइएको शुद्धता/precision/recall प्रश्नलाई गहिरो रूपमा सम्बोधन गर्छ। अध्याय 5 ले फिचर इन्जिनियरिङ र ट्युनिङले मोडेललाई राम्रो बनाउँछ। अध्याय 6 पूर्ण capstone परियोजना हो।

ढाँचा बस्छ। योग्यता बढ्छ।