Question

要在分类特征上运行编码器，在数字特征上运行Imputer（参见下文），并将它们统一在一起。
例如，具有分类特征的数值：

df_with_cat = pd.DataFrame({
           'A'      : ['ios', 'android', 'web', 'NaN'],
           'B'      : [4, 4, 'NaN', 2], 
           'target' : [1, 1, 0, 0] 
       })
df_with_cat.head()

    A        B  target
----------------------
0   ios      4    1
1   android  4    1
2   web     NaN   0
3   NaN      2    0

我们希望在数值功能上运行Imputer，即用“ most_frequent” /“ median” /“ mean” ==> Pipeline 1 替换缺失值/ NaN。但是我们要将类别特征转换为数字/ OneHotEncoding等==> 管道2

统一它们的最佳实践是什么？
p.s：使用分类器（随机森林/决策树/ GBM）统一上述两种方法

Answer 1

正如@Sergey Bushmanov所述，可以使用ColumnTransformer来实现相同的功能。

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder

df = pd.DataFrame({
           'A'      : ['ios', 'android', 'web', 'NaN'],
           'B'      : [4, 4, 'NaN', 2], 
           'target' : [1, 1, 0, 0] 
       })

categorical_features = ['A']
numeric_features = ['B']
TARGET = ['target']

df[numeric_features]=df[numeric_features].replace('NaN', np.NaN)
columnTransformer = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(), categorical_features),
        ('num', SimpleImputer( strategy='most_frequent'), numeric_features)])

columnTransformer.fit_transform(df)

#
array([[0., 0., 1., 0., 4.],
   [0., 1., 0., 0., 4.],
   [0., 0., 0., 1., 4.],
   [1., 0., 0., 0., 2.]])

Answer 2

对于此df，显然有一种很酷的方法！

df_with_cat = pd.DataFrame({
           'A'      : ['ios', 'android', 'web', 'NaN'],
           'B'      : [4, 4, 'NaN', 2], 
           'target' : [1, 1, 0, 0] 
       })

如果您不介意将sklearn升级到0.20.2，请运行：

pip3 install scikit-learn==0.20.2

并使用此解决方案（由@AI_learning建议）：

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

columnTransformer = ColumnTransformer(
    transformers=[
        ('cat', OneHotEncoder(), CATEGORICAL_FEATURES),
        ('num', Imputer( strategy='most_frequent'), NUMERICAL_FEATURES)
    ])

然后：

columnTransformer.fit(df_with_cat)

但是，如果您使用的是较早的sklearn版本，请使用以下版本：

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Imputer
from sklearn.preprocessing import LabelBinarizer, LabelEncoder 

CATEGORICAL_FEATURES = ['A']
NUMERICAL_FEATURES = ['B']
TARGET = ['target']

numerical_pipline = Pipeline([
    ('selector', DataFrameSelector(NUMERICAL_FEATURES)),
    ('imputer', Imputer(strategy='most_frequent'))
])

categorical_pipeline = Pipeline([
    ('selector', DataFrameSelector(CATEGORICAL_FEATURES)),
    ('cat_encoder', LabelBinarizerPipelineFriendly())
])

如果您引起注意，我们会错过DataFrameSelector，它不是sklearn的一部分，所以我们在这里写下：

from sklearn.base import BaseEstimator, TransformerMixin
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

让我们统一它们：

from sklearn.pipeline import FeatureUnion, make_pipeline

preprocessing_pipeline = FeatureUnion(transformer_list=[
    ('numerical_pipline', numerical_pipline),
    ('categorical_pipeline', categorical_pipeline)
])

就这样，现在开始运行：

preprocessing_pipeline.fit_transform(df_with_cat[CATEGORICAL_FEATURES+NUMERICAL_FEATURES])

现在让我们变得更加疯狂！通过分类程序管道统一它们：

from sklearn import tree
clf = tree.DecisionTreeClassifier()
full_pipeline = make_pipeline(preprocessing_pipeline, clf)

并一起训练他们：

full_pipeline.fit(df_with_cat[CATEGORICAL_FEATURES+NUMERICAL_FEATURES], df_with_cat[TARGET])

只需打开Jupyter笔记本，获取代码片段，然后自己尝试一下！

这是LabelBinarizerPipelineFriendly（）的定义：

class LabelBinarizerPipelineFriendly(LabelBinarizer):
    '''
     Wrapper to LabelBinarizer to allow usage in sklearn.pipeline
    '''

    def fit(self, X, y=None):
        """this would allow us to fit the model based on the X input."""
        super(LabelBinarizerPipelineFriendly, self).fit(X)
    def transform(self, X, y=None):
        return super(LabelBinarizerPipelineFriendly, self).transform(X)

    def fit_transform(self, X, y=None):
        return super(LabelBinarizerPipelineFriendly, self).fit(X).transform(X)

这种方法的主要优点是，您可以将经过训练的模型和所有管道都转储到pkl文件中，然后可以实时使用完全相同的模型（在生产中进行预测）

如何在机器学习中的数值和分类特征上使用统一管道？

2 个答案: