मशीन लर्निंग में लापता डेटा की समस्या के आसपास काम करने के तरीके

Question

वस्तुतः किसी भी डेटाबेस को हम मशीन लर्निंग एल्गोरिदम का उपयोग करके भविष्यवाणियां करना चाहते हैं, कुछ विशेषताओं के लिए लापता मान पाएंगे।

इस समस्या को संबोधित करने के लिए कई दृष्टिकोण हैं, जो उन विशेषताओं को छोड़ देते हैं जब तक कि वे गायब नहीं होते हैं जब तक कि वे विशेषताओं के औसत मूल्यों से नहीं भरते हैं।

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

लेकिन इससे मुझे कुछ संदेह होता है।

कोई भी कॉलम क्यों शुरू होता है? मेरा मानना ​​है कि सबसे छोटे लापता मूल्यों के साथ एक सबसे अधिक के साथ एक है

क्या लापता मूल्यों की कोई सीमा है जो इसे पूरा करने की कोशिश करने के लायक नहीं है? (उदाहरण के लिए, यदि इस विशेषता में केवल 10% मान भरे हैं, तो इसे बाहर करना अधिक दिलचस्प नहीं होगा)

क्या पारंपरिक पैकेजों या अन्य तरीकों में किसी भी तरह का कार्यान्वयन है जो मिसिंग के लिए मजबूत है?

Comments

आप जिस कला को देख रहे हैं, उसका शब्द "इंप्यूटेशन" है, जिसमें से कई इम्प्लिमेंटेशन एक लोकप्रिय, आधुनिक विकल्प है। ध्यान दें कि लापता टिप्पणियों के साथ टिप्पणियों को छोड़कर या मतलब के साथ लापता टिप्पणियों की जगह डेटा को बुरी तरह से पूर्वाग्रह कर सकती है। शुरू करने के लिए एक जगह है गेलमैन एट अल, बायेसियन डेटा एनालिसिस 3 डी संस्करण, "अध्याय 18: मिसिंग डेटा के लिए मॉडल।"

— साइकोरैक्स का कहना है कि

टिप के लिए धन्यवाद, मैं उस शब्द के साथ खोज करूंगा और कैप 18 को देखूंगा। हटाई गई लाइनें मॉडल को बहुत अधिक पूर्वाग्रह कर सकती हैं (यदि मिसिंग यादृच्छिक नहीं है, जो कि बहुत संभावना है) और औसत रखने से अर्थ के चारों ओर एक मजबूत 'जड़त्वीय भार' डाल सकता है, यह डेटा मिसिंग की विशिष्टता पर भी निर्भर करता है। मेरा बड़ा सवाल इसे संभालने के लिए सबसे अच्छा तरीका है और मेरा सुझाव मुख्य प्रतिगमन से पहले डेटा को पूरा करने के लिए पूर्व-पंजीकरण चलाने के लिए होगा (क्या ऐसा कोई पैकेज है जो मुझे ऐसा करना चाहिए या मुझे एक बनाना चाहिए?)

— sn3fru

आधुनिक कई प्रतिरूपण एक-दूसरे से गुम और ग़ैर-अनुपलब्ध डेटा के लिए एक मॉडल का अनुमान लगाते हैं। बायेसियन लापता डेटा पर ले जाता है लापता डेटा पर एक वितरण का अनुमान लगाने के लिए, मनाया डेटा पर सशर्त और लापता होने के लिए मॉडल है। अजगर में सांख्यिकीय सॉफ्टवेयर वांछित होने के लिए बहुत कुछ छोड़ देता है। TSCS डेटा के लिए, Amelia IIR में एक ठोस विकल्प है। या आप अपने स्वयं के उपयोग से रोल कर सकते हैं stan।

— साइकोरैक्स का कहना है कि मोनिका

Answer 1

आप जिस तकनीक का वर्णन करते हैं, उसे अनुक्रमिक रजिस्टरों द्वारा प्रतिरूपण कहा जाता है या जंजीर समीकरणों के द्वारा कई प्रतिरूपण किया जाता है। रघुनाथन (2001) द्वारा इस तकनीक का बीड़ा उठाया गया और एक अच्छी तरह से काम कर रहे आर पैकेज में लागू किया गया mice(वैन ब्यूरेन, 2012)।

शेफ़र और ग्राहम (2002) का एक पेपर अच्छी तरह से समझाता है कि क्यों अभिप्रेरण और लिस्टवाइज़ विलोपन (जिसे आप लाइन अपवर्जन कहते हैं) आमतौर पर उपर्युक्त तकनीकों का कोई अच्छा विकल्प नहीं हैं। मुख्य रूप से अभिप्रेत अभिप्रेरण सशर्त नहीं है और इस प्रकार देखे गए माध्य के प्रति आसन्न वितरणों को पूर्वाग्रहित कर सकता है। यह विखंडित वितरण पर अन्य अवांछनीय प्रभावों के बीच विचरण को भी सिकोड़ देगा। इसके अलावा, लिस्ट वाइज विलोपन वास्तव में केवल तभी काम करेगा जब डेटा पूरी तरह से यादृच्छिक रूप से गायब हो, जैसे कि सिक्के के फ्लिप द्वारा। इसके अलावा, यह नमूना त्रुटि को बढ़ाएगा, क्योंकि नमूना आकार कम हो जाता है।

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

आमतौर पर, क्योंकि कुछ अप्रतिबंधित धारणाएँ शामिल होती हैं, विशेष रूप से रैंडम डेटा (यानी डेटा का अवलोकन किया जाता है या नहीं, केवल अवलोकन किए गए डेटा पर निर्भर करता है, और नायाब मूल्यों पर निर्भर करता है)। साथ ही प्रक्रियाएं आंशिक रूप से असंगत हो सकती हैं, यही वजह है कि उन्हें PIGS (आंशिक रूप से असंगत गिब्स नमूना) कहा गया है।

व्यवहार में बेइज़ियन बहु प्रतिरूपण अभी भी बहुभिन्नरूपी गैर-मोनोटोन लापता डेटा समस्याओं से निपटने का एक अच्छा तरीका है। इसके अलावा, गैर-पैरामीट्रिक एक्सटेंशन जैसे कि पूर्वानुमान माध्य मिलान प्रतिगमन मॉडलिंग मान्यताओं को आराम करने में मदद करते हैं।

---

रघुनाथन, टीई, लेपकोव्स्की, जे।, वैन होएविक, जे।, और सोलेनबर्गर, पी। (2001)। प्रतिगमन मॉडल के अनुक्रम का उपयोग करके लापता मूल्यों को गुणा करने के लिए एक बहुभिन्नरूपी तकनीक। सर्वेक्षण पद्धति, 27 (1), 85-95।

शेफर, जेएल, और ग्राहम, जेडब्ल्यू (2002)। गुम डेटा: कला की स्थिति के बारे में हमारा दृष्टिकोण। मनोवैज्ञानिक तरीके, 7 (2), 147–177। https://doi.org/10.1037/1082-989X.7.2.147

वैन ब्यूरेन, एस। (2012)। लापता डेटा का लचीली प्रतिष्ठा। बोका रैटन: सीआरसी प्रेस।

Comments

उत्कृष्ट प्रतिक्रिया, एक तरफ मुझे खुशी है कि मैं कम से कम उस दिशा को आगे बढ़ाता हूं, जिसका मुझे पालन करना चाहिए, दूसरी तरफ मुझे इस बात का दुःख है कि मेरे पास ऐसा कोई जनन दृष्टिकोण नहीं है, जिसके बारे में मैंने नहीं सोचा था। बेयस विधि द्वारा लापता डेटा की संवादात्मक भविष्यवाणी पर, मैं अजगर में इस तरह से कुछ कैसे पुन: पेश कर सकता हूं? क्या यह एक प्रतिगमन भी है? और सभी संभव लापता डेटा की भविष्यवाणी करने के बाद, क्या मुझे भविष्यवक्ता के ऊपर जाना चाहिए ताकि नया डेटा भी उस भविष्यवाणी में भाग ले? मदद के लिए बहुत धन्यवाद, मेरा मानना ​​है कि यह कई अन्य लोगों को फायदा होगा।

— 19

@ sn3fru खैर, इन सवालों का जवाब अन्य स्थानों के संदर्भों में दिया गया है। मुझे पता नहीं है कि पायथन कार्यान्वयन मौजूद है, लेकिन इसकी नकल करना बहुत मुश्किल नहीं होना चाहिए। मुझे लगता है कि इसे एल्गोरिथ्म के विवरण का थोड़ा अध्ययन करना होगा। सामान्य तौर पर किसी भी बायेशियन मॉडल का उपयोग कई अशुद्धियां बनाने के लिए किया जा सकता है, लेकिन miceएल्गोरिथ्म या तो प्रतिगमन या भविष्य कहनेवाला मिलान का उपयोग करता है। आप प्रारंभ में अनुपलब्ध डेटा को देखे गए वितरण से आकर्षित करते हैं और फिर क्रमिक रूप से लागू करते हैं। एक बार समाप्त होने के बाद आप दोहराते हैं, लेकिन नए लगाए गए मूल्यों का उपयोग करते हुए। नया डेटा भाग लेता है, हाँ

— tomka

Answer 2

मुझे कुछ भी नहीं मिला जिससे मेरी समस्या हल हो गई, इसलिए मैंने एक फ़ंक्शन लिखा, जो पंडों के डेटाफ़्रेम के कुछ समाधानों को लापता संख्यात्मक मूल्यों (कल्पना के साथ) और श्रेणीबद्ध (एक यादृच्छिक जंगल के साथ) के साथ मिलाता है।

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
import fancyimpute as fi

def separe_numeric_categoric(df):
    numerics = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
    df_n = df.select_dtypes(include=numerics)
    df_c = df.select_dtypes(exclude=numerics)
    print(f'The DF have {len(list(df_n))} numerical features and {len(list(df_c))} categorical fets')
    return df_n, df_c


def find_missing(df):
    total = df.isnull().sum().sort_values(ascending=False)
    percent = (df.isnull().sum()/df.isnull().count()).sort_values(ascending=False)
    filter(lambda x: x>=minimum, percent)
    return percent


def count_missing(df):
    missing = find_missing(df)
    total_columns_with_missing = 0
    for i in (missing):
        if i>0:
            total_columns_with_missing += 1
    return total_columns_with_missing


def remove_missing_data(df,minimum=.1):
    percent = find_missing(df)
    number = len(list(filter(lambda x: x>=(1.0-minimum), percent)))
    names = list(percent.keys()[:number])
    df = df.drop(names, 1, errors='ignore')
    print(f'{number} columns exclude because haven`t minimium data.')
    return df


def one_hot(df, cols):
    for each in cols:
        dummies = pd.get_dummies(df[each], prefix=each, drop_first=False)
        df = pd.concat([df, dummies], axis=1)
    df = df.drop(cols, axis=1)
    return df



def impute_missing_data(df,minimium_data=.1):
    columns_missing = count_missing(df)
    print(f'Total columns with missing values: {count_missing(df)} of a {len(list(df))} columns in df')

    # remove features without minimium size of information
    df = remove_missing_data(df,minimium_data)

    numerical_df, categorical_df = separe_numeric_categoric(df)

    # Autocomplete using MICE for numerical features.
    try:
        df_numerical_complete = fi.MICE(verbose=False).complete(numerical_df.values)
        n_missing = count_missing(df)
        print(f'{columns_missing-n_missing} numerical features imputated')

        # Complete the columns name.
        temp = pd.DataFrame(columns=numerical_df.columns, data=df_numerical_complete)

        # df temp com os dados numericos completados e os categóricos.
        df = pd.concat([temp, categorical_df], axis=1)

    except Exception as e:
        print(e)
        print('Without Missing data in numerical features')

    missing = find_missing(df)
    names = missing.keys()
    n = 0
    for i, c in enumerate(missing):
        if c > 0:
            col = names[i]
            print(f'Start the prediction of {col}')
            clf = RandomForestClassifier()
            le = LabelEncoder()
            ## inverter a ordem da predição das categóricas pode melhorar a precisao.
            categorical_train = list(categorical_df.loc[:,categorical_df.columns != col])

            temp = one_hot(df,categorical_train)
            df1 = temp[temp[col].notnull()]
            df2 = temp[temp[col].isnull()]
            df1_x = df1.loc[:, df1.columns != col]
            df2_x = df2.loc[:, df1.columns != col]

            df1_y = df1[col]
            le.fit(df1_y)
            df1_y = le.transform(df1_y)
            clf.fit(df1_x, df1_y)
            df2_yHat = clf.predict(df2_x)
            df2_yHat = le.inverse_transform(df2_yHat)
            df2_yHat = pd.DataFrame(data=df2_yHat, columns=[col])
            df1_y = le.inverse_transform(df1_y)
            df1_y = pd.DataFrame(data=df1_y,columns=[col])

            df2_x.reset_index(inplace=True)   
            result2 = pd.concat([df2_yHat, df2_x], axis=1)
            try:
                del result2['index']
            except:
                pass

            df1_x.reset_index(inplace=True)
            result1 = pd.concat([df1_y, df1_x], axis=1)
            try:
                del result1['index']
            except:
                pass

            result = pd.concat([result1, result2])
            result = result.set_index(['Id'])
            df.reset_index()            
            try:
                df.set_index(['Id'],inplace=True)
            except:
                pass
            df[col] = result[col]

            n += 1

    print(f'Number of columns categorical with missing data solved: {n}')

    return df


df = impute_missing_data(df)

Comments

अच्छा, यह दूसरों की मदद कर सकता है (मैंने इसकी जांच नहीं की) - यह आपके लिए Rफ़ंक्शन के निर्माता mice, स्टीफ वैन बुरेन से संपर्क करने के लिए भी दिलचस्प हो सकता है । वह आपके पायथन कोड में दिलचस्पी ले सकता है और / या आपको इस संबंध में अन्य लोगों के काम की ओर इशारा करता है। stefvanbuuren.nl

— टॉमका

मुझे नहीं पता कि क्या वे इतनी सरल चीज़ में दिलचस्पी लेंगे, मैं यहाँ साझा कर रहा हूँ क्योंकि यह अन्य लोगों को पंडों के डेटाफ़्रेम में लापता को हल करने में मदद कर सकता है।

— sn3fru

वैसे वे इसे सामान्य रूप से पायथन में लागू करने के लिए इच्छुक हो सकते हैं और उन्हें पता चल सकता है कि क्या किसी ने पहले ही कर दिया है। मैंने पहले स्टीफ से संपर्क किया है और वह बहुत ही संवेदनशील और मददगार है। यदि एक पायथन कार्यान्वयन है, तो इसे इस धागे के तहत यहां साझा करना भी उपयोगी हो सकता है। उदाहरण के लिए देखें pypi.python.org/pypi/fancyimpute/0.0.4

— tomka

Answer 3

आमतौर पर अधिक शामिल होने के बावजूद, आप कोशिश कर सकते हैं कि आपके पास किस डेटा के आधार पर अधिकतम एन्ट्रापी वितरण हो।

http://proceedings.mlr.press/v5/huang09a/huang09a.pdf