web-dev-qa-db-fra.com

Comment utiliser Sklearn Column Transformer?

J'essaie de convertir la valeur catégorielle (dans mon cas, c'est la colonne de pays) en valeur codée à l'aide de LabelEncoder puis avec OneHotEncoder et j'ai pu convertir la valeur catégorielle. Mais je reçois un avertissement comme le mot-clé "categorical_features" de OneHotEncoder est déconseillé "utilisez plutôt ColumnTransformer." Alors, comment puis-je utiliser ColumnTransformer pour obtenir le même résultat?

Voici mon jeu de données d'entrée et le code que j'ai essayé

Input Data set

Country Age Salary
France  44  72000
Spain   27  48000
Germany 30  54000
Spain   38  61000
Germany 40  67000
France  35  58000
Spain   26  52000
France  48  79000
Germany 50  83000
France  37  67000


import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder, OneHotEncoder

#X is my dataset variable name

label_encoder = LabelEncoder()
x.iloc[:,0] = label_encoder.fit_transform(x.iloc[:,0]) #LabelEncoder is used to encode the country value
hot_encoder = OneHotEncoder(categorical_features = [0])
x = hot_encoder.fit_transform(x).toarray()

Et la sortie que j'obtiens, comment puis-je obtenir la même sortie avec un transformateur de colonne

0(fran) 1(ger) 2(spain) 3(age)  4(salary)
1         0       0      44        72000
0         0       1      27        48000
0         1       0      30        54000
0         0       1      38        61000
0         1       0      40        67000
1         0       0      35        58000
0         0       1      36        52000
1         0       0      48        79000
0         1       0      50        83000
1         0       0      37        67000

j'ai essayé de suivre le code

from sklearn.compose import ColumnTransformer, make_column_transformer

preprocess = make_column_transformer(

    ( [0], OneHotEncoder())
)
x = preprocess.fit_transform(x).toarray()

j'ai pu coder la colonne du pays avec le code ci-dessus, mais il manque la colonne d'âge et de salaire de x variable après la transformation

pythonscikit-learn
18
chinna g

Je pense que l'affiche n'essaie pas de transformer l'âge et le salaire. De la documentation ( https://scikit-learn.org/stable/modules/generated/sklearn.compose.make_column_transformer.html ), vous ColumnTransformer (et make_column_transformer) uniquement les colonnes spécifiées dans le transformateur (c'est-à-dire , [0] dans votre exemple). Vous devez définir reste = "passthrough" pour obtenir le reste des colonnes. En d'autres termes:

preprocessor = make_column_transformer( (OneHotEncoder(),[0]),remainder="passthrough")
x = preprocessor.fit_transform(x)
11
passerby

Il est étrange que vous souhaitiez encoder des données continues en salaire. Cela n'a de sens que si vous avez regroupé votre salaire dans certaines fourchettes/catégories. Si je vous où je ferais:

import pandas as pd
import numpy as np

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder



numeric_features = ['Salary']
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())])

categorical_features = ['Age','Country']
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

à partir d'ici, vous pouvez le diriger avec un classificateur, par exemple.

clf = Pipeline(steps=[('preprocessor', preprocessor),
                  ('classifier', LogisticRegression(solver='lbfgs'))])

Utilisez-le ainsi:

clf.fit(X_train,y_train)

cela appliquera le préprocesseur, puis passera les données transformées au prédicteur.

11
Prayson W. Daniel
from sklearn.compose import make_column_transformer
preprocess = make_column_transformer(
    (OneHotEncoder(categories='auto'), [0]), 
    remainder="passthrough")
X = preprocess.fit_transform(X)

J'ai résolu le même problème en utilisant le code ci-dessus.

2
Arvind Chavhan

La méthode la plus simple consiste à utiliser pandas nuls sur votre trame de données CVS

dataset = pd.read_csv("yourfile.csv")
dataset = pd.get_dummies(dataset,columns=['Country'])

terminé Votre jeu de données ressemblera à ceci Output

2
Shiva_Adasule

@Fawwaz Yusran Pour faire face à cet avertissement ...

FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values. If you want the future behaviour and silence this warning, you can specify "categories='auto'". In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly. warnings.warn(msg, FutureWarning)

Supprimez les éléments suivants ...

labelencoder_X = LabelEncoder()
X[:, 0] = labelencoder_X.fit_transform(X[:, 0])

Puisque vous utilisez directement OneHotEncoder, vous n'avez pas besoin de LabelEncoder.

1
Yung

Vous pouvez utiliser directement le OneHotEncoder et n'avez pas besoin d'utiliser le LabelEncoder

#  Encoding categorical data
from sklearn.preprocessing import OneHotEncoder
transformer = ColumnTransformer(
    transformers=[
        ("OneHotEncoder",
         OneHotEncoder(),
         [0]              # country column or the column on which categorical operation to be performed
         )
    ],
    remainder='passthrough'
)
X = transformer.fit_transform(X.tolist())
0
Suresh Mangs

Puisque vous ne transformez que la colonne de pays (c'est-à-dire [0] dans votre exemple). Utilisation remainder="passthrough" pour obtenir les colonnes restantes afin que vous obteniez ces colonnes telles quelles.

essayer:

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
labelencoder=LabelEncoder()
x[:,0]=labelencoder.fit_transform(x[:,0])
preprocess = ColumnTransformer(transformers=[('onehot', OneHotEncoder() 
                               [0])],remainder="passthrough")
x = np.array(preprocess.fit_transform(x), dtype=np.int)
0
Lekha