label-encoder-Kodierung fehlende Werte

Ich bin mit label-encoder zum konvertieren von kategorischen Daten in numerische Werte.

Wie funktioniert LabelEncoder behandelt fehlende Werte?

from sklearn.preprocessing import LabelEncoder
import pandas as pd
import numpy as np
a = pd.DataFrame(['A','B','C',np.nan,'D','A'])
le = LabelEncoder()
le.fit_transform(a)

Ausgabe:

array([1, 2, 3, 0, 4, 1])

Für das oben genannte Beispiel, label encoder geändert NaN-Werte zu einer Kategorie. Wie würde ich wissen, welche Kategorie steht für fehlende Werte?

InformationsquelleAutor saurabh agarwal | 2016-04-23

10

Nicht verwenden LabelEncoder mit fehlenden Werten. Ich weiß nicht, welche version von scikit-learn Sie verwenden, aber in 0.17.1 dein code wirft TypeError: unorderable types: str() > float().

Wie Sie sehen können in der Quelle es nutzt numpy.unique gegen die Daten zu Kodieren, was wirft TypeError wenn die fehlenden Werte gefunden werden. Wenn du encodieren willst, fehlende Werte, zuerst ändern Sie den Typ in einen string:
```
a[pd.isnull(a)]  = 'NaN'
```
So würden Sie die Codierung 'NaN' als dummy-Wert? Ich habe das gleiche Problem, aber möchten, verwenden Sie den kalkulatorischen Wert für die lineare regression.

InformationsquelleAutor dukebody

Hallo, ein wenig Rechenleistung hack habe ich zu meiner eigenen Arbeit:

from sklearn.preprocessing import LabelEncoder
import pandas as pd
import numpy as np
a = pd.DataFrame(['A','B','C',np.nan,'D','A'])
le = LabelEncoder()
### fit with the desired col, col in position 0 for this example
fit_by = pd.Series([i for i in a.iloc[:,0].unique() if type(i) == str])
le.fit(fit_by)
### Set transformed col leaving np.NaN as they are
a["transformed"] = fit_by.apply(lambda x: le.transform([x])[0] if type(x) == str else x)

fit_by ist eine Liste, Listen, die nicht über ein .apply() Methode, bitte korrigieren

InformationsquelleAutor Kerem T

Füllen Sie die na ' s von Wert und später ändern Sie das dataframe Spalte Typ auf string.

from sklearn.preprocessing import LabelEncoder
import pandas as pd
import numpy as np
a = pd.DataFrame(['A','B','C',np.nan,'D','A'])
a.fillna(99)
le = LabelEncoder()
le.fit_transform(a.astype(str))

InformationsquelleAutor raghu nanden

Dies ist meine Lösung, weil ich war nicht zufrieden mit den Lösungen, die hier gepostet. Ich brauchte eine LabelEncoder hält, dass meine fehlende Werte als " NaN " aus, um eine Imputer danach. So ich geschrieben habe, meine eigenen LabelEncoder Klasse. Sie arbeiten mit DataFrames.

from sklearn.base import BaseEstimator
from sklearn.base import TransformerMixin
from sklearn.preprocessing import LabelEncoder

class LabelEncoderByCol(BaseEstimator, TransformerMixin):
    def __init__(self,col):
        #List of column names in the DataFrame that should be encoded
        self.col = col
        #Dictionary storing a LabelEncoder for each column
        self.le_dic = {}
        for el in self.col:
            self.le_dic[el] = LabelEncoder()

    def fit(self,x,y=None):
        #Fill missing values with the string 'NaN'
        x[self.col] = x[self.col].fillna('NaN')
        for el in self.col:
            #Only use the values that are not 'NaN' to fit the Encoder
            a = x[el][x[el]!='NaN']
            self.le_dic[el].fit(a)
        return self

    def transform(self,x,y=None):
        #Fill missing values with the string 'NaN'
        x[self.col] = x[self.col].fillna('NaN')
        for el in self.col:
            #Only use the values that are not 'NaN' to fit the Encoder
            a = x[el][x[el]!='NaN']
            #Store an ndarray of the current column
            b = x[el].get_values()
            #Replace the elements in the ndarray that are not 'NaN'
            #using the transformer
            b[b!='NaN'] = self.le_dic[el].transform(a)
            #Overwrite the column in the DataFrame
            x[el]=b
        #return the transformed DataFrame
        return x

Können Sie einen DataFrame, der nicht nur ein 1-dim-Serie. mit col können Sie wählen die Spalten aus, die codiert werden sollten.

Ich würde gerne hier ein feedback.

Ich verwendet newdf = LabelEncoderByCol(df) - nun, wie wandle ich es um pandas?

InformationsquelleAutor Niclas von Caprivi

können Sie auch eine Maske verwenden, ersetzen den ursprünglichen Daten-frame nach Kennzeichnung

df = pd.DataFrame({'A': ['x', np.NaN, 'z'], 'B': [1, 6, 9], 'C': [2, 1, np.NaN]})

    A   B   C
0   x   1   2.0
1   NaN 6   1.0
2   z   9   NaN

dfTmp = df
mask = df_1.isnull()
       A    B   C
0   False   False   False
1   True    False   False
2   False   False   True

df = df.astype(str).apply(LabelEncoder().fit_transform)
df.where(~mask, original)

A   B   C
0   1.0 0   1.0
1   NaN 1   0.0
2   2.0 2   NaN

InformationsquelleAutor ulrich

0

Ich vor dem gleichen problem, aber keine der oben genannten für mich gearbeitet. Also ich habe eine neue Zeile mit den Trainingsdaten, bestehend nur "nan"

InformationsquelleAutor silent_dev

Folgenden encoder-Adressen Keine Werte in jeder Kategorie.

class MultiColumnLabelEncoder:
    def __init__(self):
        self.columns = None
        self.led = defaultdict(preprocessing.LabelEncoder)

    def fit(self, X):
        self.columns = X.columns
        for col in self.columns:
            cat = X[col].unique()
            cat = [x if x is not None else "None" for x in cat]
            self.led[col].fit(cat)
        return self

    def fit_transform(self, X):
        if self.columns is None:
            self.fit(X)
        return self.transform(X)

    def transform(self, X):
        return X.apply(lambda x:  self.led[x.name].transform(x.apply(lambda e: e if e is not None else "None")))

    def inverse_transform(self, X):
        return X.apply(lambda x: self.led[x.name].inverse_transform(x))

Verwendet Beispiel

df = pd.DataFrame({
    'pets': ['cat', 'dog', 'cat', 'monkey', 'dog', 'dog'],
    'owner': ['Champ', 'Ron', 'Brick', None, 'Veronica', 'Ron'],
    'location': ['San_Diego', 'New_York', 'New_York', 'San_Diego', 'San_Diego',
                 None]
})


print(df)

   location     owner    pets
0  San_Diego     Champ     cat
1   New_York       Ron     dog
2   New_York     Brick     cat
3  San_Diego      None  monkey
4  San_Diego  Veronica     dog
5       None       Ron     dog

le = MultiColumnLabelEncoder()
le.fit(df)

transformed = le.transform(df)
print(transformed)

   location  owner  pets
0         2      1     0
1         0      3     1
2         0      0     0
3         2      2     2
4         2      4     1
5         1      3     1

inverted = le.inverse_transform(transformed)
print(inverted)

        location     owner    pets
0  San_Diego     Champ     cat
1   New_York       Ron     dog
2   New_York     Brick     cat
3  San_Diego      None  monkey
4  San_Diego  Veronica     dog
5       None       Ron     dog

InformationsquelleAutor Ashok Kumar Pant

Dies ist, wie ich es gemacht habe:

import pandas as pd
from sklearn.preprocessing import LabelEncoder

UNKNOWN_TOKEN = '<unknown>'
a = pd.Series(['A','B','C', 'D','A'], dtype=str).unique().tolist()
a.append(UNKNOWN_TOKEN)
le = LabelEncoder()
le.fit_transform(a)
embedding_map = dict(zip(le.classes_, le.transform(le.classes_)))

und bei der Anwendung neuer test-Daten:

test_df = test_df.apply(lambda x: x if x in embedding_map else UNKNOWN_TOKEN)
le.transform(test_df)

InformationsquelleAutor muon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.