Imputieren Sie kategoriale fehlende Werte in scikit-learn

Ich habe pandas-Daten mit mehreren Spalten des Typs text. Es gibt einige NaN-Werte zusammen mit diesen text-Spalten. Was ich versuche zu tun, ist zu unterstellen, diejenigen, die NaN ' s von sklearn.preprocessing.Imputer (ersetzt NaN durch den häufigsten Wert). Das problem ist in der Umsetzung.
Angenommen, es ist ein Pandas dataframe df mit 30 Spalten, von denen 10 sind kategorialer Natur.
Sobald ich laufen:

from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN', strategy='most_frequent', axis=0)
imp.fit(df)

Python erzeugt eine error: 'could not convert string to float: 'run1''wo "run1" ist eine gewöhnliche (nicht fehlenden) Wert aus der ersten Spalte mit kategorischen Daten.

Jede Hilfe wäre sehr willkommen

InformationsquelleAutor der Frage night_bat | 2014-08-11

Verwenden der Mittelwerte für numerische Spalten und der häufigste Wert für nicht-numerische Spalten Sie könnte so etwas tun. Man könnte weiter unterscheiden zwischen Ganzzahlen und Fließkommazahlen. Ich denke, es könnte Sinn machen, verwenden Sie den median für integer-Spalten.

import pandas as pd
import numpy as np

from sklearn.base import TransformerMixin

class DataFrameImputer(TransformerMixin):

    def __init__(self):
        """Impute missing values.

        Columns of dtype object are imputed with the most frequent value 
        in column.

        Columns of other types are imputed with mean of column.

        """
    def fit(self, X, y=None):

        self.fill = pd.Series([X[c].value_counts().index[0]
            if X[c].dtype == np.dtype('O') else X[c].mean() for c in X],
            index=X.columns)

        return self

    def transform(self, X, y=None):
        return X.fillna(self.fill)

data = [
    ['a', 1, 2],
    ['b', 1, 1],
    ['b', 2, 2],
    [np.nan, np.nan, np.nan]
]

X = pd.DataFrame(data)
xt = DataFrameImputer().fit_transform(X)

print('before...')
print(X)
print('after...')
print(xt)

dem Drucke,

before...
     0   1   2
0    a   1   2
1    b   1   1
2    b   2   2
3  NaN NaN NaN
after...
   0         1         2
0  a  1.000000  2.000000
1  b  1.000000  1.000000
2  b  2.000000  2.000000
3  b  1.333333  1.666667

InformationsquelleAutor der Antwort sveitser

3

Können Sie sklearn_pandas.CategoricalImputer für die kategorischen Spalten. Details:

Ersten, (aus dem Buch " Hands-On Machine Learning mit Scikit-Learn und TensorFlow) können Sie subpipelines für numerische und string - /kategoriale Funktionen, wobei jede subpipeline ersten Transformator ist ein Selektor, die eine Liste von Spaltennamen (und die full_pipeline.fit_transform() nimmt ein pandas DataFrame):
```
class DataFrameSelector(BaseEstimator, TransformerMixin):
    def __init__(self, attribute_names):
        self.attribute_names = attribute_names
    def fit(self, X, y=None):
        return self
    def transform(self, X):
        return X[self.attribute_names].values
```
Können Sie dann kombinieren Sie diese sub-pipelines mit sklearn.pipeline.FeatureUnion zum Beispiel:
```
full_pipeline = FeatureUnion(transformer_list=[
    ("num_pipeline", num_pipeline),
    ("cat_pipeline", cat_pipeline)
])
```
Nun, in der num_pipeline können Sie einfach sklearn.preprocessing.Imputer()aber in der cat_pipline verwenden, können Sie CategoricalImputer() von der sklearn_pandas Paket.

Hinweis: sklearn-pandas - Paket kann installiert werden, mit pip install sklearn-pandasaber es ist importiert import sklearn_pandas

InformationsquelleAutor der Antwort Austin

Inspiriert durch die Antworten hier und für die wollen der eine goto-Imputer für alle Einsatz-Fälle landete ich dies Schreibe. Es unterstützt vier Strategien für die Zuschreibung mean, mode, median, fill funktioniert auf beiden pd.DataFrame und Pd.Series.

mean und median funktioniert nur bei numerischen Daten mode und fill funktioniert sowohl für numerische und kategorische Daten.

class CustomImputer(BaseEstimator, TransformerMixin):
    def __init__(self, strategy='mean',filler='NA'):
       self.strategy = strategy
       self.fill = filler

    def fit(self, X, y=None):
       if self.strategy in ['mean','median']:
           if not all(X.dtypes == np.number):
               raise ValueError('dtypes mismatch np.number dtype is \
                                 required for '+ self.strategy)
       if self.strategy == 'mean':
           self.fill = X.mean()
       elif self.strategy == 'median':
           self.fill = X.median()
       elif self.strategy == 'mode':
           self.fill = X.mode().iloc[0]
       elif self.strategy == 'fill':
           if type(self.fill) is list and type(X) is pd.DataFrame:
               self.fill = dict([(cname, v) for cname,v in zip(X.columns, self.fill)])
       return self

   def transform(self, X, y=None):
       return X.fillna(self.fill)

Nutzung

>> df   
    MasVnrArea  FireplaceQu
Id  
1   196.0   NaN
974 196.0   NaN
21  380.0   Gd
5   350.0   TA
651 NaN     Gd


>> CustomImputer(strategy='mode').fit_transform(df)
MasVnrArea  FireplaceQu
Id      
1   196.0   Gd
974 196.0   Gd
21  380.0   Gd
5   350.0   TA
651 196.0   Gd

>> CustomImputer(strategy='fill', filler=[0, 'NA']).fit_transform(df)
MasVnrArea  FireplaceQu
Id      
1   196.0   NA
974 196.0   NA
21  380.0   Gd
5   350.0   TA
651 0.0     Gd

InformationsquelleAutor der Antwort Gautham Kumaran

Dieser code füllt in eine Reihe mit den häufigsten Kategorie:

import pandas as pd
import numpy as np

# create fake data 
m = pd.Series(list('abca'))
m.iloc[1] = np.nan #artificially introduce nan

print('m = ')
print(m)

#make dummy variables, count and sort descending:
most_common = pd.get_dummies(m).sum().sort_values(ascending=False).index[0] 

def replace_most_common(x):
    if pd.isnull(x):
        return most_common
    else:
        return x

new_m = m.map(replace_most_common) #apply function to original data

print('new_m = ')
print(new_m)

Ausgänge:

m =
0      a
1    NaN
2      c
3      a
dtype: object

new_m =
0    a
1    a
2    c
3    a
dtype: object

InformationsquelleAutor der Antwort scottlittle

Kopieren und ändern sveitser Antwort, ich habe eine imputer für pandas.Serie Objekt

import numpy
import pandas 

from sklearn.base import TransformerMixin

class SeriesImputer(TransformerMixin):

    def __init__(self):
        """Impute missing values.

        If the Series is of dtype Object, then impute with the most frequent object.
        If the Series is not of dtype Object, then impute with the mean.  

        """
    def fit(self, X, y=None):
        if   X.dtype == numpy.dtype('O'): self.fill = X.value_counts().index[0]
        else                            : self.fill = X.mean()
        return self

    def transform(self, X, y=None):
       return X.fillna(self.fill)

Verwenden Sie es tun würden:

# Make a series
s1 = pandas.Series(['k', 'i', 't', 't', 'e', numpy.NaN])


a  = SeriesImputer()   # Initialize the imputer
a.fit(s1)              # Fit the imputer
s2 = a.transform(s1)   # Get a new series

InformationsquelleAutor der Antwort user1367204

Ähnlich. Ändern Imputer für strategy='most_frequent':

class GeneralImputer(Imputer):
    def __init__(self, **kwargs):
        Imputer.__init__(self, **kwargs)

    def fit(self, X, y=None):
        if self.strategy == 'most_frequent':
            self.fills = pd.DataFrame(X).mode(axis=0).squeeze()
            self.statistics_ = self.fills.values
            return self
        else:
            return Imputer.fit(self, X, y=y)

    def transform(self, X):
        if hasattr(self, 'fills'):
            return pd.DataFrame(X).fillna(self.fills).values.astype(str)
        else:
            return Imputer.transform(self, X)

wo pandas.DataFrame.mode() findet der häufigste Wert für jede Spalte und dann pandas.DataFrame.fillna() füllt fehlende Werte mit diesen. Andere strategy Werte sind immer noch auf die gleiche Weise behandelt, indem Imputer.

InformationsquelleAutor der Antwort Jack

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.