web-dev-qa-db-fra.com

Get_dummies de Panda contre OneHotEncoder () de Sklearn :: Quels sont les avantages et les inconvénients?

J'apprends différentes méthodes pour convertir des variables catégorielles en numérique pour les classificateurs d'apprentissage automatique. Je suis tombé sur la méthode pd.get_dummies Et sklearn.preprocessing.OneHotEncoder() et je voulais voir comment ils différaient en termes de performances et d'utilisation.

J'ai trouvé un tutoriel sur la façon d'utiliser OneHotEnocder() sur https://xgdgsc.wordpress.com/2015/03/20/note-on-using-onehotencoder-in-scikit-learn- to-work-on-categorical-features / puisque la documentation sklearn n'était pas très utile sur cette fonctionnalité. J'ai le sentiment que je ne le fais pas correctement ... mais

Certains peuvent-ils expliquer les avantages et les inconvénients de l'utilisation de pd.dummies Sur sklearn.preprocessing.OneHotEncoder() et vice versa? Je sais que OneHotEncoder() vous donne une matrice clairsemée mais à part ça, je ne sais pas comment elle est utilisée et quels sont les avantages par rapport à la méthode pandas. Suis-je l'utiliser de manière inefficace?

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
sns.set()

%matplotlib inline

#Iris Plot
iris = load_iris()
n_samples, m_features = iris.data.shape

#Load Data
X, y = iris.data, iris.target
D_target_dummy = dict(Zip(np.arange(iris.target_names.shape[0]), iris.target_names))

DF_data = pd.DataFrame(X,columns=iris.feature_names)
DF_data["target"] = pd.Series(y).map(D_target_dummy)
#sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  \
#0                  5.1               3.5                1.4               0.2   
#1                  4.9               3.0                1.4               0.2   
#2                  4.7               3.2                1.3               0.2   
#3                  4.6               3.1                1.5               0.2   
#4                  5.0               3.6                1.4               0.2   
#5                  5.4               3.9                1.7               0.4   

DF_dummies = pd.get_dummies(DF_data["target"])
#setosa  versicolor  virginica
#0         1           0          0
#1         1           0          0
#2         1           0          0
#3         1           0          0
#4         1           0          0
#5         1           0          0

from sklearn.preprocessing import OneHotEncoder, LabelEncoder
def f1(DF_data):
    Enc_ohe, Enc_label = OneHotEncoder(), LabelEncoder()
    DF_data["Dummies"] = Enc_label.fit_transform(DF_data["target"])
    DF_dummies2 = pd.DataFrame(Enc_ohe.fit_transform(DF_data[["Dummies"]]).todense(), columns = Enc_label.classes_)
    return(DF_dummies2)

%timeit pd.get_dummies(DF_data["target"])
#1000 loops, best of 3: 777 µs per loop

%timeit f1(DF_data)
#100 loops, best of 3: 2.91 ms per loop
pythonpandasmachine-learningscikit-learndummy-variable
40
O.rka

OneHotEncoder ne peut pas traiter directement les valeurs de chaîne. Si vos entités nominales sont des chaînes, vous devez d'abord les mapper en entiers.

pandas.get_dummies est un peu l'inverse. Par défaut, il convertit uniquement les colonnes de chaînes en une représentation unique, sauf si des colonnes sont spécifiées.

41
nos

Pour l'apprentissage automatique, vous voulez presque certainement utiliser sklearn.OneHotEncoder. Pour d'autres tâches comme les analyses simples, vous pourrez peut-être utiliser pd.get_dummies, ce qui est un peu plus pratique.

Notez que sklearn.OneHotEncoder a été mis à jour dans la dernière version afin qu'il accepte les chaînes pour les variables catégorielles, ainsi que les entiers.

L'essentiel est que l'encodeur sklearn crée une fonction qui persiste et peut puis être appliquée à de nouveaux ensembles de données qui utilisent les mêmes variables catégorielles, avec des résultats cohérents.

from sklearn.preprocessing import OneHotEncoder

# Create the encoder.
encoder = OneHotEncoder(handle_unknown="ignore")
encoder.fit(X_train)    # Assume for simplicity all features are categorical.

# Apply the encoder.
X_train = encoder.transform(X_train)
X_test = encoder.transform(X_test)

Notez comment nous appliquons le même encodeur que nous avons créé via X_train vers le nouvel ensemble de données X_test.

Considérez ce qui se passe si X_test contient des niveaux différents de X_train pour l'une de ses variables. Par exemple, disons X_train["color"] ne contient que "red" et "green", mais en plus de ceux-ci, X_test["color"] contient parfois "blue".

Si nous utilisons pd.get_dummies, X_test se terminera par un "color_blue" colonne qui X_train n'en a pas, et l'incohérence cassera probablement notre code plus tard, surtout si nous alimentons X_test vers un modèle sklearn que nous avons formé sur X_train.

Et si nous voulons traiter les données comme celle-ci en production, où nous recevons un seul exemple à la fois, pd.get_dummies ne sera pas utile.

Avec sklearn.OneHotEncoder d'autre part, une fois que nous avons créé l'encodeur, nous pouvons le réutiliser pour produire la même sortie à chaque fois, avec des colonnes uniquement pour "red" et "green". Et nous pouvons contrôler explicitement ce qui se passe quand il rencontre le nouveau niveau "blue": si nous pensons que c'est impossible, alors nous pouvons lui dire de lancer une erreur avec handle_unknown="error"; sinon nous pouvons lui dire de continuer et mettre simplement les colonnes rouge et verte à 0, avec handle_unknown="ignore".

18
Denziloe