पायथन में कोलीनियर चर को व्यवस्थित रूप से कैसे हटाया जाए? [बन्द है]

Question

इस प्रकार, मैंने सहसंबंध तालिकाओं को देखकर और एक निश्चित सीमा से ऊपर वाले चरों को समाप्त करके डेटा तैयारी प्रक्रिया के भाग के रूप में कोलिनियर वेरिएबल्स को हटा दिया है। क्या ऐसा करने का अधिक स्वीकृत तरीका है? इसके अतिरिक्त, मुझे पता है कि केवल एक समय में 2 चर के बीच संबंध को देखना आदर्श नहीं है, VIF जैसे माप कई चर में संभावित सहसंबंध को ध्यान में रखते हैं। कोई व्यक्ति वैवाहिक संयोजनों को व्यवस्थित रूप से चुनने के बारे में कैसे जानेगा जो बहुसंस्कृति का प्रदर्शन नहीं करते हैं?

मेरे पास एक पंडों के डेटा फ्रेम के भीतर मेरा डेटा है और मैं स्केलेन के मॉडल का उपयोग कर रहा हूं।

Comments

आप आंशिक कमानी वर्ग प्रतिगमन या प्रधान घटक प्रतिगमन पर विचार करना चाह सकते हैं। इनमें से एक शायद समर्थित है।

— sprrnl

समझा। इसलिए अगर मैं सही ढंग से समझूं, तो पीसीए चलाने से मुझे स्वतंत्र प्रिंसिपल घटकों का एक सेट मिलेगा, जिसे मैं तब अपने मॉडल के लिए कोवरिएट्स के रूप में उपयोग कर सकता हूं, क्योंकि प्रत्येक प्रमुख घटक दूसरों के साथ कॉलिनियर नहीं है?

— नारंगी

बिल्कुल सही। कुछ घटकों के अप्रासंगिक होने की संभावना है। यह चर छोड़ने की तुलना में आसान है।

— ११:१३ पर ११

एचएम, इसलिए मेरा इरादा मुख्य रूप से भविष्य कहनेवाला उद्देश्यों के बजाय व्याख्यात्मक के लिए मॉडल को चलाना है। कोई एक मॉडल की व्याख्या करने के बारे में कैसे जानेगा जो प्रिंसिपल घटकों को कोवरिएट के रूप में इस्तेमाल करता है?

— नारंगी

उस मामले में यह मदद नहीं करता है क्योंकि घटकों की व्याख्या करना कुछ हद तक एक काली कला है।

— sprrnl

Answer 1

धन्यवाद स्पेनिशबॉय - यह कोड का एक अच्छा टुकड़ा है। @ilanman: यह VIF मानों की जाँच करता है और फिर चर को छोड़ता है जिसका VIF 5. "प्रदर्शन" से अधिक है, मुझे लगता है कि वह समय भी शामिल करता है। उपरोक्त कोड मुझे लगभग 300 चर, 5000 पंक्तियों पर चलने में लगभग 3 घंटे का समय लगा।

वैसे, मैंने कुछ अतिरिक्त छोरों को हटाने के लिए इसे संशोधित किया है। इसके अलावा, मैंने इसे थोड़ा साफ कर दिया है और कम चर के साथ डेटाफ्रेम लौटाता है। इस संस्करण ने मेरे रन टाइम को आधा कर दिया है! मेरा कोड नीचे है- आशा है कि यह मदद करता है।

from statsmodels.stats.outliers_influence import variance_inflation_factor    

def calculate_vif_(X, thresh=5.0):
    variables = list(range(X.shape[1]))
    dropped = True
    while dropped:
        dropped = False
        vif = [variance_inflation_factor(X.iloc[:, variables].values, ix)
               for ix in range(X.iloc[:, variables].shape[1])]

        maxloc = vif.index(max(vif))
        if max(vif) > thresh:
            print('dropping \'' + X.iloc[:, variables].columns[maxloc] +
                  '\' at index: ' + str(maxloc))
            del variables[maxloc]
            dropped = True

    print('Remaining variables:')
    print(X.columns[variables])
    return X.iloc[:, variables]

Comments

धन्यवाद। क्या आपने दोनों कार्यों के आउटपुट की तुलना की है? मैंने VIF के लिए एक R फंक्शन (पैकेज usdmमेथड vifstep) देखा और रन टाइम वास्तव में अच्छा था। जैसा कि मैंने पहले कहा, ऊपर और आपके (आधे द्वारा अनुकूलित) आर के साथ तुलना करने में बहुत धीमी है। किसी भी अन्य विचार अभी तक कैसे अनुकूलित करें?

— स्पेनिशबॉय

इस दृष्टिकोण के बारे में मेरा एक प्रश्न है। मान लीजिए कि हमारे पास ए, बी और सी विशेषताएं हैं। A, C के साथ सहसंबद्ध है। यदि आप सुविधाओं पर लूप करते हैं, तो A और C में VIF> 5 होगा, इसलिए उन्हें हटा दिया जाएगा। वास्तव में, हर बार जब आप कोई सुविधा छोड़ते हैं, तो आपको VIF की गणना नहीं करनी चाहिए। मेरे उदाहरण में आप A और C दोनों को छोड़ देंगे, लेकिन यदि आप A को गिराए जाने के बाद VIF (C) की गणना करते हैं, तो यह नहीं हो रहा है> 5

— टाइटस पुलो

Answer 2

आप नीचे दिए गए कोड का उपयोग करने का प्रयास कर सकते हैं:

from statsmodels.stats.outliers_influence import variance_inflation_factor

def calculate_vif_(X):

    '''X - pandas dataframe'''
    thresh = 5.0
    variables = range(X.shape[1])

    for i in np.arange(0, len(variables)):
        vif = [variance_inflation_factor(X[variables].values, ix) for ix in range(X[variables].shape[1])]
        print(vif)
        maxloc = vif.index(max(vif))
        if max(vif) > thresh:
            print('dropping \'' + X[variables].columns[maxloc] + '\' at index: ' + str(maxloc))
            del variables[maxloc]

    print('Remaining variables:')
    print(X.columns[variables])
    return X

यह काम करता है, लेकिन मुझे उस दृष्टिकोण का प्रदर्शन पसंद नहीं है

Comments

क्या आप इस बारे में कुछ और टिप्पणी करना चाहते हैं कि यह दृष्टिकोण क्या करता है? और आपको प्रदर्शन पसंद क्यों नहीं है?

— इलमैन

Answer 3

मैंने स्पैनिशबॉय के उत्तर की कोशिश की और डेटा-फ्रेम के लिए इसे चलाते समय सर्वोपरि त्रुटियां पाईं। यहाँ एक डीबग किया गया समाधान है।

from statsmodels.stats.outliers_influence import variance_inflation_factor    

def calculate_vif_(X, thresh=100):
cols = X.columns
variables = np.arange(X.shape[1])
dropped=True
while dropped:
    dropped=False
    c = X[cols[variables]].values
    vif = [variance_inflation_factor(c, ix) for ix in np.arange(c.shape[1])]

    maxloc = vif.index(max(vif))
    if max(vif) > thresh:
        print('dropping \'' + X[cols[variables]].columns[maxloc] + '\' at index: ' + str(maxloc))
        variables = np.delete(variables, maxloc)
        dropped=True

print('Remaining variables:')
print(X.columns[variables])
return X[cols[variables]]

मेरे पास प्रदर्शन के साथ कोई समस्या नहीं थी, लेकिन बड़े पैमाने पर इसका परीक्षण नहीं किया है।

Comments

यह अच्छा है और मेरे लिए काम करता है। को छोड़कर, यह अशुभ चेतावनी देता है:RuntimeWarning: divide by zero encountered in double_scalars

— user2205916