炸裂！Sklearn 的 10 个宝藏级使用方法！-编程知识

大家好，本次给大家介绍10个Sklearn方法，比较小众但非常好用。

1️.FunctionTransformer

虽然Sklearn中有很多内置的预处理操作可以放进pipeline管道，但很多时候并不能满足我们的需求。

如果是比较简单并且通过一个函数可以实现需求的情况，我们可以将函数通过FunctionTransformer进行包装生成可与Sklearn兼容的转换器，然后装进pipeline。

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTransformerdef reduce_memory(X: pd.DataFrame, y=None):"""将数值型列的类型转换为float32类型，以减少内存占用"""num_cols = X.select_dtypes(incluce=np.number).columnsfor col in num_cols:X[col] = X.astype("float32")return X, yReduceMemoryTransformer = FunctionTransformer(reduce_memory)# 装进一个pipeline
>>> make_pipeline(SimpleImputer(), ReduceMemoryTransformer)Pipeline(steps=[('simpleimputer', SimpleImputer()),('functiontransformer', ReduceMemoryTransformer()])

技术交流

技术要学会分享、交流，不建议闭门造车。一个人可以走的很快、一堆人可以走的更远。

本文由粉丝群小伙伴总结与分享，如果你也想学习交流，资料获取，均可加交流群获取，群友已超过2000人，添加时最好的备注方式为：来源+兴趣方向，方便找到志同道合的朋友。

方式①、添加微信号：dkl88194，备注：来自CSDN + 加群
方式②、微信搜索公众号：Python学习与数据挖掘，后台回复：加群

2.自定义transformers

但有更复杂需求的时候，可能一个简单函数也是无法完成功能实现的，这时就需要自己实实在在地创建一个转换器了。

比如，数据清洗中比较常见的操作缩放特征变量并使其呈正态分布。通常我们会使用对数变换器如PowerTransformer或np.log，但默认的方法会有一点问题，即如果某个特征包含零值，那么底层的对数函数无法处理会提出报错。

因此，一般的应对方法是将特征向量加上1，然后再执行转换，以避免报错。如果想要还原原始向量，直接调用指数函数然后再减去1，就可以了。非常的丝滑。

当然，这个操作并未内置于Sklearn中，并且也不是一个简单函数能搞定的。下面看看如何自定义一个转换器解决这个问题。

from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.preprocessing import PowerTransformerclass CustomLogTransformer(BaseEstimator, TransformerMixin):def __init__(self):self._estimator = PowerTransformer()  # 初始化一个转换器def fit(self, X, y=None):X_copy = np.copy(X) + 1  # 防止零值出现报错，进行加一操作self._estimator.fit(X_copy)return selfdef transform(self, X):X_copy = np.copy(X) + 1return self._estimator.transform(X_copy)  # 执行转换def inverse_transform(self, X):X_reversed = self._estimator.inverse_transform(np.copy(X))return X_reversed - 1  # 指数函数后减一

上面创建了一个类，继承了BaseEstimator并使其TransformerMixin能够插入pipeline管道的类。

3.TransformedTargetRegressor

有些时候，不仅仅是特征X需要处理，目标变量y也需要预处理操作。一个典型的场景就是我们上面提到的缩放数据使其呈现正态分布。通常我们会在pipeline以外做额外的处理，但 Sklearn 有一个方法可以同时在管道中处理。

TransformedTargetRegressor是一个专门针对regressor回归器进行转换的类，通过它可以同时将特征X和目标变量y在管道pipeline中做处理。比如下面的lgb回归的例子，它使用CustomLogTransformer对目标y进行对数缩放，然后拟合回归模型。

from sklearn.compose import TransformedTargetRegressorreg_lgbm = lgbm.LGBMRegressor()final_estimator = TransformedTargetRegressor(regressor=reg_lgbm, transformer=CustomLogTransformer()
)final_estimator.fit(X_train, y_train)
TransformedTargetRegressor(regressor=LGBMRegressor(),transformer=CustomLogTransformer())

如果转换器是一个函数如np.log，可以将其传递给func参数。

4.管道流程图

如果管道由多个步骤或子管道组成，代码上可能会比较混乱。Sklearn提供了估计器的HTML表示形式，让整理处理流程更直观清晰：

>>> giant_pipelinePipeline(steps=[('columntransformer',ColumnTransformer(transformers=[('cat_pipe',Pipeline(steps=[('impute',SimpleImputer(strategy='most_frequent')),('oh',OneHotEncoder())]),<sklearn.compose._column_transformer.make_column_selector object at 0x000001B6D8BD9310>),('num_pipe',Pipeline(steps=[('impute',SimpleImputer(strategy='median')),('transform',QuantileTransformer())]),<sklearn.compose._column_transformer.make_column_selector object at 0x000001B6D8BD9160>)])),('lgbmregressor',LGBMRegressor(device_type='gpu', learning_rate=0.01,n_estimators=10000))])

from sklearn import set_configset_config(display="diagram")>>> giant_pipeline

将dispaly参数设置为diagram，就可以获得管道的HTML的交互式形式。

5.QuadraticDiscriminantAnalysis

QDA为QuadraticDiscriminantAnalysis的简称，是二次判别分析的意思。在Kaggle竞赛中，即使没有超参数调整，二次判别分析分类器也可以获得AUC0.965这样高的分数，超过了大多数树模型，包括XGBoost和LightGBM。

那为什么之前很少听说过该算法呢？因为它的使用有严格的限制条件，它要求训练特征严格的正态分布，这样QDA就可以轻松计算并拟合分布周围的椭球形状了。

QDA 的另一个优点是它的速度非常快，在百万行数据集上训练它只需要几秒钟。以下是QDA在Sklearn中的执行速度。

%%timefrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis# Generate 1M samples and 100 features
X, y = make_classification(n_samples=1000000, n_features=100)
qda = QuadraticDiscriminantAnalysis().fit(X, y)Wall time: 13.4 s

6.Voting Classifier/Regressor

在模型训练中，我们经常会遇到几个模型效果相似的情况，想要进一步提升效果，这时可以使用投票方法，是一种简单的模型集成方法。

投票方法效果提升原因在于概率论，简单来说就是少数服从多数。具体的就是，投票分类器会将多个分类器的多数票作为最终预测，而如果类别是概率或预测是连续的，则对预测进行平均。

Sklearn提供了两个方法VotingClassifier和VotingRegressor，我们只需要传递一个分类器或回归器的列表，将它们组合起来就可以了。下面是VotingClassifier的示例。

from sklearn.ensemble import VotingClassifierX, y = make_classification(n_samples=1000)ensemble = VotingClassifier(estimators=[("xgb", xgb.XGBClassifier(eval_metric="auc")),("lgbm", lgbm.LGBMClassifier()),("cb", cb.CatBoostClassifier(verbose=False)),],voting="soft",# n_jobs=-1,
)_ = ensemble.fit(X, y)

以上设置voting参数为soft，代表预测是概率。此外，还可以为不同的模型分配weights权重系数进行更精准的预测。

7.Stacking Classifier/Regressor

另一种比投票更强大的集成方法是stacking。

stacking背后的思想是，子模型应该尽可能多样化，因为不同的模型从不同的角度学习训练集的信息，可以覆盖整个信息空间。

换句话说，各种模型（如树、线性模型、表面拟合器、近邻模型、贝叶斯模型和高斯模型）最大化了训练潜力，它们的组合输出减少了偏差并防止了过拟合。

Kaggle竞赛中，stacking是一个提分的神器，很多获胜方案中都有提及。示例代码如下。

from sklearn.ensemble import StackingClassifier, StackingRegressor
from sklearn.linear_model import LogisticRegressionX, y = make_classification(n_samples=1000)ensemble = StackingClassifier(estimators=[("xgb", xgb.XGBClassifier(eval_metric="auc")),("lgbm", lgbm.LGBMClassifier()),("cb", cb.CatBoostClassifier(verbose=False)),],final_estimator=LogisticRegression(),cv=5,passthrough=False# n_jobs=-1,
)_ = ensemble.fit(X, y)

8.LocalOutlierFactor

异常值会使模型的目标函数产生偏差，可能导致过于乐观或过于悲观的结果。

对于小数据集来说，查找异常值不成问题。如果特征超过50-100个时，就需要一种快速准确的算法来检测高维异常值了。

对于具有数百个特征和数百万行的数据集，原始算法可能也需要运行几个小时。这时可以将降维算法与异常值检测方法结合起来，一个比较好的组合是UMAP和LocalOutlierFactor。LocalOutlierFactor是一种基于近邻的算法，旨在快速处理大型数据集。

%%timeimport umap  # pip install umap
from sklearn.neighbors import LocalOutlierFactorX, y = make_classification(n_samples=5000, n_classes=2, n_features=10)
X_reduced = umap.UMAP(n_components=2).fit_transform(X, y)lof = LocalOutlierFactor()
labels = lof.fit_predict(X_reduced, y)Wall time: 17.8 s>>> np.where(labels == -1)
(array([ 119,  155,  303,  331,  333,  407,  418,  549,  599,  664,  795,3092, 3262, 3271, 3280, 3289, 3311, 3477, 3899, 3929, 3975, 4301,4358, 4442, 4522, 4561, 4621, 4631, 4989], dtype=int64),)

9️.QuantileTransformer

某些时候得到的模型结果分布非常不规则，可能通过对数转换器或缩放器都无法强制转换为正态分布，比如双峰、三峰、或者n峰的分布。

这种情况下可以使用QuantileTransformer，它使用分位数的统计指标实现中心化和缩放分布。

import pandas as pd
from sklearn.preprocessing import QuantileTransformerqt = QuantileTransformer().fit(crazy_distributions)crazy_feature_names = ["f18", "f31", "f61"]
crazy_distributions = pd.DataFrame(qt.transform(crazy_distributions), columns=crazy_feature_names)fig, axes = plt.subplots(1, 3, figsize=(20, 6))for ax, f_name in zip(axes.flatten(), crazy_feature_names):sns.kdeplot(crazy_distributions[f_name], ax=ax, color="#E50914")

PCA + tSNE/UMAP

这个一个降维的组合使用方法。因为PCA主成分分析对于高维度处理速度是比较快的，因此通常作为第一阶段的处理方法，比如使用PCA缩减到30-50的维度，然后再用其他算法如tSNE或UMAP作为第二阶段的处理方法。

下面是 PCA 和 tSNE 的组合：

from sklearn.decomposition import PCA
from sklearn.manifold import TSNEdf = dt.fread("data/large.csv").to_pandas()>>> df.shape
(1000000, 287)X, y = df.drop("target", axis=1), df[["target"]].values.flatten()%%time
manifold_pipe = make_pipeline(QuantileTransformer(), PCA(n_components=30), TSNE())reduced_X = manifold_pipe.fit_transform(X, y)------------------------------------------Wall time: 4h 27min 46s

以上在100万行和约300个特征的数据集上，先通过PCA投影到前30个维度，然后再投影到二维，整个过程需要4.5小时，并且结果也不是很好。

>>> plt.scatter(reduced_X[:, 0], reduced_X[:, 1], c=y, s=0.05);

因此建议使用UMAP，它比tSNE快得多，并且可以更好地保留了数据的局部结构。

%%time
manifold_pipe = make_pipeline(QuantileTransformer(), PCA(n_components=30))X_pca = manifold_pipe.fit_transform(X, y)
embedding = umap.UMAP(n_components=2).fit(X_pca, y)Wall time: 14min 27s>>> plt.scatter(embedding.embedding_[:, 0], embedding.embedding_[:, 1], c=y, s=0.05);