Comment coder un ensemble de données ayant plusieurs types de données ?

Question

J'ai un ensemble de données comme :

e = pd.DataFrame({
    'col1': ['A', 'A', 'B', 'W', 'F', 'C'],
    'col2': [2, 1, 9, 8, 7, 4],
    'col3': [0, 1, 9, 4, 2, 3],
    'col4': ['a', 'B', 'c', 'D', 'e', 'F']
})

Ici, j'ai encodé les données en utilisant sklearn.preprocessing.LabelEncoder . Par les lignes de code suivantes :

x = list(e.columns)
# Import label encoder 
from sklearn import preprocessing 

# label_encoder object knows how to understand word labels. 
label_encoder = preprocessing.LabelEncoder() 
for i in x:  
# Encode labels in column 'species'. 
    e[i] = label_encoder.fit_transform(e[i])
print(e) 

Mais il s'agit d'encoder même le point de données numérique de int qui n'est pas obligatoire.

Ensemble de données codées :

col1  col2  col3  col4
0     0     1     0     3
1     0     0     1     0
2     1     5     5     4
3     4     4     4     1
4     3     3     2     5
5     2     2     3     2

Comment puis-je y remédier ?

Answer 1

Une possibilité très simple consisterait à n'encoder que les colonnes contenant des valeurs de type chaîne. Par exemple, en modifiant votre code pour qu'il soit :

import pandas as pd
from sklearn import preprocessing 

e = pd.DataFrame({
    'col1': ['A', 'A', 'B', 'W', 'F', 'C'],
    'col2': [2, 1, 9, 8, 7, 4],
    'col3': [0, 1, 9, 4, 2, 3],
    'col4': ['a', 'B', 'c', 'D', 'e', 'F']
})

label_encoder = preprocessing.LabelEncoder() 
for col in e.columns:  
    if e[col].dtype == 'O':
        e[col] = label_encoder.fit_transform(e[col])

print(e) 

ou mieux encore :

import pandas as pd
from sklearn import preprocessing 

def encode_labels(ser):
    if ser.dtype == 'O':
        return label_encoder.fit_transform(ser)
    else:
        return ser

label_encoder = preprocessing.LabelEncoder() 
e = pd.DataFrame({
    'col1': ['A', 'A', 'B', 'W', 'F', 'C'],
    'col2': [2, 1, 9, 8, 7, 4],
    'col3': [0, 1, 9, 4, 2, 3],
    'col4': ['a', 'B', 'c', 'D', 'e', 'F']
})

e_encoded = e.apply(encode_labels)
print(e_encoded)

Answer 2

Filtrer et adapter votre prétraitement aux types de colonnes est une bonne idée, et la manière la plus efficace de le faire est le pipeline pandas.

from sklearn.compose import ColumnTransformer
from sklearn.compose import make_column_selector
from sklearn.preprocecssing import LabelEncoder, StandardScaler

Exemple 1 : application d'un transformateur en fonction du nom de la colonne

my_transformer1 = ColumnTransformer(
                     [
                         ('transform_name_for_col1', LabelEncoder(), 'col1'),
                         ('transformer_name_for_col2_and_col3', StandardScaler(), ['col2', 'col3'])
                     ]
                 )

Exemple 2 : application d'un transformateur en fonction du type de colonne

my_transformer2 = ColumnTransformer(
                     [
                         ('transform_name_categories', LabelEncoder(), make_column_selector(dtype_include=object)),
                         ('transformer_name_for_numerical', StandardScaler(), make_column_selector(dtype_include=np.number))
                     ]
                 )

Évidemment, remplacez LabelEncoder et StandardScaler par le transformateur de votre choix, y compris un transformateur personnalisé :

class MyCustomTransformer(BaseEstimator, TransformerMixin):
    def __init__(self):
        # do something

    def fit(self, X, y = None):
        # do something
        return self

    def transform(self, X, y = None):
        # do something
        # return something transformed

Pour aller plus loin, je recommande d'utiliser scikit-learn Pipeline pour combiner différents prétraitements en fonction de la colonne et/ou du type de colonne (ce qui sera beaucoup plus flexible).

Voir les détails du cours ici :

• https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_selector.html
• https://scikit-learn.org/stable/modules/generated/sklearn.compose.ColumnTransformer.html
• https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html