Machine Learning

Python में चरणबद्ध प्रतिगमन में महारथ: एक व्यापक मार्गदर्शिका

Spread the love

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

विषयवस्तु की तालिका

अग्र चयन

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

पश्चगामी निष्कासन

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

चरणबद्ध चयन (द्विदिशात्मक)

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

statsmodels के साथ चरणबद्ध प्रतिगमन

statsmodels में एक अंतर्निहित चरणबद्ध प्रतिगमन फ़ंक्शन नहीं है, लेकिन हम इसके OLS (ऑर्डिनरी लीस्ट स्क्वायर) मॉडल का उपयोग करके मैन्युअल रूप से अग्र चयन लागू कर सकते हैं:


import pandas as pd
import numpy as np
import statsmodels.api as sm
from statsmodels.formula.api import ols

# नमूना डेटा
data = {'y': [10, 12, 15, 18, 20, 22, 25, 28, 30, 32],
        'x1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
        'x2': [2, 4, 6, 8, 10, 12, 14, 16, 18, 20],
        'x3': [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]}
df = pd.DataFrame(data)

def forward_selection(data, target, significance_level=0.05):
    included = []
    while True:
        changed=False
        excluded = list(set(data.columns)-set(included)-{target})
        best_pvalue = 1.0
        best_feature = None
        for new_column in excluded:
            model = sm.OLS(target, sm.add_constant(data[included+[new_column]])).fit()
            pvalue = model.pvalues[new_column]
            if pvalue < best_pvalue:
                best_pvalue = pvalue
                best_feature = new_column
        if best_pvalue < significance_level:
            included.append(best_feature)
            changed=True
        if not changed: break
    return included

selected_features = forward_selection(df, df['y'])
print(f"चयनित विशेषताएँ: {selected_features}")
final_model = sm.OLS(df['y'], sm.add_constant(df[selected_features])).fit()
print(final_model.summary())

sklearn के साथ चरणबद्ध प्रतिगमन

sklearn फीचर चयन के लिए रिकर्सिव फीचर एलिमिनेशन (RFE) का उपयोग करता है। RFE एक बेस मॉडल (जैसे रैखिक प्रतिगमन) से उनके महत्व स्कोर के आधार पर क्रमिक रूप से सुविधाओं को हटाता है:


from sklearn.linear_model import LinearRegression
from sklearn.feature_selection import RFE
from sklearn.model_selection import train_test_split

X = df.drop('y', axis=1)
y = df['y']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LinearRegression()
rfe = RFE(model, n_features_to_select=2) # आवश्यकतानुसार समायोजित करें
rfe = rfe.fit(X_train, y_train)

print(f"चयनित विशेषताएँ: {X.columns[rfe.support_]}")

final_model = LinearRegression().fit(X_train[X.columns[rfe.support_]], y_train)
print(f"परीक्षण सेट पर R-वर्ग: {final_model.score(X_test[X.columns[rfe.support_]], y_test)}")

mlxtend के साथ चरणबद्ध प्रतिगमन

mlxtend का SequentialFeatureSelector अग्र, पश्चगामी या चरणबद्ध चयन करने का एक सुविधाजनक तरीका प्रदान करता है:


from mlxtend.feature_selection import SequentialFeatureSelector as SFS
from sklearn.linear_model import LinearRegression

model = LinearRegression()
sfs = SFS(model, k_features='best', forward=True, floating=False, scoring='r2', cv=5) #अग्र चयन

sfs = sfs.fit(X, y)

print(f"चयनित विशेषताएँ: {list(sfs.k_feature_idx_)}")

final_model = LinearRegression().fit(X[X.columns[list(sfs.k_feature_idx_)]], y)

सही विधि और विचार चुनना

चरणबद्ध प्रतिगमन विधि (अग्र, पश्चगामी, या चरणबद्ध) और उपयोग किए गए पुस्तकालय का चुनाव विशिष्ट डेटासेट और लक्ष्यों पर निर्भर करता है। विचार करना याद रखें:

  • डेटा आकार: बड़ी संख्या में पूर्वानुमानकों के साथ पश्चगामी निष्कासन महंगा हो सकता है।
  • बहुसहसंबंध: चरणबद्ध विधियाँ अत्यधिक सहसंबद्ध पूर्वानुमानकों के साथ संघर्ष कर सकती हैं।
  • व्याख्यात्मकता बनाम भविष्य कहनेवाला सटीकता: एक सरल मॉडल (कम चर) व्याख्या करने में आसान हो सकता है, भले ही थोड़ा कम सटीक हो।
  • क्रॉस-सत्यापन: सामान्यीकरण सुनिश्चित करने के लिए हमेशा k-गुना क्रॉस-सत्यापन जैसी तकनीकों का उपयोग करके अपने मॉडल को सत्यापित करें।

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

प्रातिक्रिया दे

आपका ईमेल पता प्रकाशित नहीं किया जाएगा. आवश्यक फ़ील्ड चिह्नित हैं *