精华内容
下载资源
问答
  • 如何用Python计算特征重要性

    千次阅读 2020-07-07 16:10:07
    特征重要性评分是一种为输入特征评分的手段,其依据是输入特征在预测目标变量过程中的有用程度。 特征重要性有许多类型和来源,尽管有许多比较常见,比如说统计相关性得分,线性模型的部分系数,基于决策树的特征...

    特征重要性评分是一种为输入特征评分的手段,其依据是输入特征在预测目标变量过程中的有用程度。

    特征重要性有许多类型和来源,尽管有许多比较常见,比如说统计相关性得分,线性模型的部分系数,基于决策树的特征重要性和经过随机排序得到重要性得分。

    特征重要性在预测建模项目中起着重要作用,包括提供对数据、模型的见解,以及如何降维和选择特征,从而提高预测模型的的效率和有效性。

    在本教程中,我将会阐述用于python机器学习的特征重要性。完成本教程后,你将会知道:

    • 特征重要性在预测建模中的作用
    • 如何计算和查看来自线性模型和决策树的特征重要性
    • 如何计算和查看随机排序重要性得分

    现在让我们开始吧.

    教程概述

    本教程分为五部分,分别是:

    1.特征重要性

    2.准备

    2.1. 检查Scikit-Learn版本

    2.2. 创建测试数据集

    3.特征重要性系数

    3.1. 基于线性回归系数的特征重要性

    3.2. 基于Logistic回归的特征重要性

    4.基于决策树的特征重要性

    4.1. 基于CART的特征重要性

    4.2. 基于随机森林的特征重要性

    4.3. 基于XGBoost的特征重要性

    5.随机排序特征重要性

    5.1. 随机排序(回归)中的特征重要性

    5.2. 随机排序(分类)中的特征重要性

    1.特征重要性

    特征重要性是一种为预测模型的输入特征评分的方法,该方法揭示了进行预测时每个特征的相对重要性。

    可以为涉及预测数值的问题(称为回归)和涉及预测类别标签的问题(称为分类)计算特征重要性得分。

    这些得分非常有用,可用于预测建模问题中的多种情况,例如:

    • 更好地理解数据
    • 更好地理解模型
    • 减少输入特征的数量

     

    特征重要性得分可以帮助了解数据集

    相对得分可以突出显示哪些特征可能与目标最相关,反之则突出哪些特征最不相关。这可以由一个领域专家解释,并且可以用作收集更多的或不同的数据的基础。

    特征重要性得分可以帮助了解模型

    大多数重要性得分是通过数据集拟合出的预测模型计算的。查看重要性得分可以洞悉该特定模型,以及知道在进行预测时哪些特征最重要和哪些最不重要。这是一种模型解释,适用于那些支持它的模型。

    特征重要性可用于改进预测模型

    可以使用的重要性得分来选择要删除的特征(最低得分)或要保留的特征(最高得分)。这是一种特征选择,可以简化正在建模的问题,加快建模过程(删除特征称为降维),在某些情况下,还可以改善模型的性能。

    特征重要性得分可以被输入到包装器模型,如SelectFromModel或SelectKBest,以进行特征选择。

    有许多方法和模型可以计算特征重要性得分。

    也许最简单的方法是计算每个特征和目标变量之间的统计学相关系数。

    在本教程中,我们将研究三种比较高级的特征重要性,即:

    • 从模型系数得知的特征重要性。
    • 决策树中的特征重要性。
    • 随机排序检验中的特征重要性。

    现在让我们深入了解这三个!

    2.准备

    在深入学习之前,我们先确认我们的环境并准备一些测试数据集。

    检查Scikit-Learn版本

    首先,确认你已安装最新版本的scikit-learn库。这非常重要,因为在本教程中,我们我们研究的一些模型需要最新版的库。

    您可以使用以下示例代码来查看已安装的库的版本:

    1. # check scikit-learn version
    2. import sklearn
    3. print(sklearn.__version__)

    运行示例代码将会打印出库的版本。在撰写本文时,大概是version 0.22。你需要使用此版本或更高版本的scikit-learn。

    1. 0.22.1

    生成测试数据集

    接下来,让我们生成一些测试数据集,这些数据集可以作为基础来证明和探索特征重要性得分。每个测试问题有五个重要特征和五不重要的特征,看看哪种方法可以根据其重要性找到或区分特征可能会比较有意思。

    分类数据集

    我们将使用make_classification()函数创建一个用于测试的二进制分类数据集。

    数据集将包含1000个实例,且包含10个输入特征,其中五个将会提供信息,其余五个是多余的。

    为了确保每次运行代码时都得到相同的实例,我们将使用假随机数种子。下面列出了创建数据集的示例。

    1. # test classification dataset
    2. from sklearn.datasets import make_classification
    3. # define dataset
    4. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    5. # summarize the dataset
    6. print(X.shape, y.shape)

    运行示例,创建数据集,并确保所需的样本和特征数量。

    1. (1000, 10) (1000,)

    回归数据集

    我们将使用make_regression()函数创建一个用于测试的回归数据集。

    像分类数据集一样,回归数据集将包含1000个实例,且包含10个输入特征,其中五个将会提供信息,其余五个是多余的。

    1. # test regression dataset
    2. from sklearn.datasets import make_regression
    3. # define dataset
    4. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    5. # summarize the dataset
    6. print(X.shape, y.shape)

    运行示例,创建数据集,并确保所需的样本和特征数量。

    1. (1000, 10) (1000,)

    接下来,我们仔细看一下特征重要性系数。

    3.特征重要性系数

    线性的机器学习能够拟合出预测是输入值的加权和的模型。

    案例包括线性回归,逻辑回归,和正则化的扩展案例,如岭回归和弹性网络。

    所有这些算法都是找到一组要在加权求和中使用的系数,以便进行预测。这些系数可以直接用作粗略类型的特征重要性得分。

    我们来仔细研究一下分类和回归中的特征重要性系数。我们将在数据集中拟合出一个模型以找到系数,然后计算每个输入特征的重要性得分,最终创建一个条形图来了解特征的相对重要性。

    3.1线性回归特征重要性

    我们可以在回归数据集中拟合出一个LinearRegression模型,并检索coeff_属性,该属性包含为每个输入变量(特征)找到的系数。这些系数可以为粗略特征重要性评分提供依据。该模型假设输入变量具有相同的比例或者在拟合模型之前已被按比例缩放。

    下面列出了针对特征重要性的线性回归系数的完整示例。

    1. # linear regression feature importance
    2. from sklearn.datasets import make_regression
    3. from sklearn.linear_model import LinearRegression
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    7. # define the model
    8. model = LinearRegression()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.coef_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    得分表明,模型找到了五个重要特征,并用零标记了剩下的特征,实际上,将他们从模型中去除了。

    1. Feature: 0, Score: 0.00000
    2. Feature: 1, Score: 12.44483
    3. Feature: 2, Score: -0.00000
    4. Feature: 3, Score: -0.00000
    5. Feature: 4, Score: 93.32225
    6. Feature: 5, Score: 86.50811
    7. Feature: 6, Score: 26.74607
    8. Feature: 7, Score: 3.28535
    9. Feature: 8, Score: -0.00000
    10. Feature: 9, Score: 0.00000

    然后为特征重要性得分创建条形图。

     

    这种方法也可以用于岭回归和弹性网络模型。

    3.2 Logistic回归特征重要性

    就像线性回归模型一样,我们也可以在回归数据集中拟合出一个LogisticRegression模型,并检索coeff_属性。这些系数可以为粗略特征重要性评分提供依据。该模型假设输入变量具有相同的比例或者在拟合模型之前已被按比例缩放。

    下面列出了针对特征重要性的Logistic回归系数的完整示例。

    1. # logistic regression for feature importance
    2. from sklearn.datasets import make_classification
    3. from sklearn.linear_model import LogisticRegression
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    7. # define the model
    8. model = LogisticRegression()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.coef_[0]
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    回想一下,这是有关0和1的分类问题。请注意系数既可以为正,也可以为负。正数表示预测类别1的特征,而负数表示预测类别0的特征。

    从这些结果,至少从我所知道的结果中,无法清晰的确定出重要和不重要特征。

    1. Feature: 0, Score: 0.16320
    2. Feature: 1, Score: -0.64301
    3. Feature: 2, Score: 0.48497
    4. Feature: 3, Score: -0.46190
    5. Feature: 4, Score: 0.18432
    6. Feature: 5, Score: -0.11978
    7. Feature: 6, Score: -0.40602
    8. Feature: 7, Score: 0.03772
    9. Feature: 8, Score: -0.51785
    10. Feature: 9, Score: 0.26540

    然后为特征重要性得分创建条形图。

     

    现在我们已经看到了将系数用作重要性得分的示例,接下来让我们看向基于决策树的重要性得分的常见示例

    4.基于决策树的特征重要性

    决策树算法,比如说classification and regression trees(CART)根据Gini系数或熵的减少来提供重要性得分。这个方法也可用于随机森林和梯度提升算法。

    OK.现在让我们看看相应的运行示例。

    4.1基于CART的特征重要性

    对于在scikit-learn中实现的特征重要性,我们可以将CART算法用于DecisionTreeRegressorDecisionTreeClassifier

    拟合后,模型提供feature_importances_属性,可以访问该属性以检索每个输入特征的相对重要性得分。

    让我们看一个用于回归和分类的示例。

    基于CART(回归)的特征重要性

    下面列出了拟合DecisionTreeRegressor和计算特征重要性得分的完整示例。

    1. # decision tree for feature importance on a regression problem
    2. from sklearn.datasets import make_regression
    3. from sklearn.tree import DecisionTreeRegressor
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    7. # define the model
    8. model = DecisionTreeRegressor()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的三个可能对预测很重要。

    1. Feature: 0, Score: 0.00294
    2. Feature: 1, Score: 0.00502
    3. Feature: 2, Score: 0.00318
    4. Feature: 3, Score: 0.00151
    5. Feature: 4, Score: 0.51648
    6. Feature: 5, Score: 0.43814
    7. Feature: 6, Score: 0.02723
    8. Feature: 7, Score: 0.00200
    9. Feature: 8, Score: 0.00244
    10. Feature: 9, Score: 0.00106

    然后为特征重要性得分创建条形图。

    基于CART(分类)的特征重要性

    下面列出了拟合DecisionTreeClassifier和计算特征重要性得分的完整示例

    1. # decision tree for feature importance on a classification problem
    2. from sklearn.datasets import make_classification
    3. from sklearn.tree import DecisionTreeClassifier
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    7. # define the model
    8. model = DecisionTreeClassifier()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的四个可能对预测很重要。

    1. Feature: 0, Score: 0.01486
    2. Feature: 1, Score: 0.01029
    3. Feature: 2, Score: 0.18347
    4. Feature: 3, Score: 0.30295
    5. Feature: 4, Score: 0.08124
    6. Feature: 5, Score: 0.00600
    7. Feature: 6, Score: 0.19646
    8. Feature: 7, Score: 0.02908
    9. Feature: 8, Score: 0.12820
    10. Feature: 9, Score: 0.04745

    然后为特征重要性得分创建条形图。

    4.2随机森林中的特征重要性

    对于在scikit-learn中实现的特征重要性,我们可以将Random Forest算法用于DecisionTreeRegressorDecisionTreeClassifier类。

    拟合后,模型提供feature_importances_属性,可以访问该属性以检索每个输入特征的相对重要性得分。

    这种方法也可以与装袋和极端随机树(extraTree)算法一起使用。

    让我们看一个用于回归和分类的示例。

    随机森林(回归)中的特征重要性

    下面列出了拟合RandomForestRegressor和计算特征重要性得分的完整示例

    1. # random forest for feature importance on a regression problem
    2. from sklearn.datasets import make_regression
    3. from sklearn.ensemble import RandomForestRegressor
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    7. # define the model
    8. model = RandomForestRegressor()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的两个或三个可能对预测很重要。

    1. Feature: 0, Score: 0.00280
    2. Feature: 1, Score: 0.00545
    3. Feature: 2, Score: 0.00294
    4. Feature: 3, Score: 0.00289
    5. Feature: 4, Score: 0.52992
    6. Feature: 5, Score: 0.42046
    7. Feature: 6, Score: 0.02663
    8. Feature: 7, Score: 0.00304
    9. Feature: 8, Score: 0.00304
    10. Feature: 9, Score: 0.00283

    然后为特征重要性得分创建条形图。

    随机森林(分类)中的特征重要性

    下面列出了拟合RandomForestClassifier和计算特征重要性得分的完整示例

    1. # random forest for feature importance on a classification problem
    2. from sklearn.datasets import make_classification
    3. from sklearn.ensemble import RandomForestClassifier
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    7. # define the model
    8. model = RandomForestClassifier()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的两个或三个可能对预测很重要。

    1. Feature: 0, Score: 0.06523
    2. Feature: 1, Score: 0.10737
    3. Feature: 2, Score: 0.15779
    4. Feature: 3, Score: 0.20422
    5. Feature: 4, Score: 0.08709
    6. Feature: 5, Score: 0.09948
    7. Feature: 6, Score: 0.10009
    8. Feature: 7, Score: 0.04551
    9. Feature: 8, Score: 0.08830
    10. Feature: 9, Score: 0.04493

    然后为特征重要性得分创建条形图。

    4.3基于XGBoost的特征重要性

    XGBoost是一个库,它提供了随机梯度提升算法的高效实现。可以通过XGBRegressorXGBClassifier类将此算法与scikit-learn一起使用。

    拟合后,模型提供feature_importances_属性,可以访问该属性以检索每个输入特征的相对重要性得分。

    scikit-learn还通过GradientBoostingClassifierGradientBoostingRegressor提供了该算法,并且可以使用相同的特征选择方法

    首先,安装XGBoost库,例如:

    1. sudo pip install xgboost

    然后,通过检查版本号来确认该库已正确安装并且可以正常工作。

    1. # check xgboost version
    2. import xgboost
    3. print(xgboost.__version__)

    运行该示例,你应该看到以下版本号或者更高版本。

    1. 0.90

    有关XGBoost库的更多信息,请看:

    • XGBoost with Python

    让我们看一个用于回归和分类问题的示例。

    基于XGBoost(回归)的特征重要性

    下面列出了拟合XGBRegressor并且计算特征重要性得分的完整示例

    1. # xgboost for feature importance on a regression problem
    2. from sklearn.datasets import make_regression
    3. from xgboost import XGBRegressor
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    7. # define the model
    8. model = XGBRegressor()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的两个或三个可能对预测很重要。

    1. Feature: 0, Score: 0.00060
    2. Feature: 1, Score: 0.01917
    3. Feature: 2, Score: 0.00091
    4. Feature: 3, Score: 0.00118
    5. Feature: 4, Score: 0.49380
    6. Feature: 5, Score: 0.42342
    7. Feature: 6, Score: 0.05057
    8. Feature: 7, Score: 0.00419
    9. Feature: 8, Score: 0.00124
    10. Feature: 9, Score: 0.00491

    然后为特征重要性得分创建条形图。

    基于XGBoost(分类)的特征重要性

    下面列出了拟合XGBClassifier并且计算特征重要性得分的完整示例

    1. # xgboost for feature importance on a classification problem
    2. from sklearn.datasets import make_classification
    3. from xgboost import XGBClassifier
    4. from matplotlib import pyplot
    5. # define dataset
    6. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    7. # define the model
    8. model = XGBClassifier()
    9. # fit the model
    10. model.fit(X, y)
    11. # get importance
    12. importance = model.feature_importances_
    13. # summarize feature importance
    14. for i,v in enumerate(importance):
    15. print('Feature: %0d, Score: %.5f' % (i,v))
    16. # plot feature importance
    17. pyplot.bar([x for x in range(len(importance))], importance)
    18. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中有七个可能对预测很重要。

    1. Feature: 0, Score: 0.02464
    2. Feature: 1, Score: 0.08153
    3. Feature: 2, Score: 0.12516
    4. Feature: 3, Score: 0.28400
    5. Feature: 4, Score: 0.12694
    6. Feature: 5, Score: 0.10752
    7. Feature: 6, Score: 0.08624
    8. Feature: 7, Score: 0.04820
    9. Feature: 8, Score: 0.09357
    10. Feature: 9, Score: 0.02220

    然后为特征重要性得分创建条形图。

    5.基于随机排序的特征重要性

    随机排序特征重要性(Permutation feature importance)可以计算相对重要性,与所使用的模型无关。

    首先,在数据集中拟合出一个模型,比如说一个不支持本地特征重要性评分的模型。然后,尽管对数据集中的特征值进行了干扰,但仍可以使用该模型进行预测。对数据集中的每个特征进行此操作。然后,再将整个流程重新操作3、5、10或更多次。我们得到每个输入特征的平均重要性得分(以及在重复的情况下得分的分布)。

    此方法可以用于回归或分类,要求选择性能指标作为重要性得分的基础,例如回归中的均方误差和分类中的准确性。

    可以通过permutation_importance()函数(以模型和数据集为参数)和评分函数进行随机排序特性选择。

    让我们看下这个特征选择方法,其算法并不支持特征选择,尤其是k近邻算法( k-nearest neighbors)。

    5.1随机排序(回归)特征重要性

    下面列出了拟合KNeighborsRegressor并且计算特征重要性得分的完整示例。

    1. # permutation feature importance with knn for regression
    2. from sklearn.datasets import make_regression
    3. from sklearn.neighbors import KNeighborsRegressor
    4. from sklearn.inspection import permutation_importance
    5. from matplotlib import pyplot
    6. # define dataset
    7. X, y = make_regression(n_samples=1000, n_features=10, n_informative=5, random_state=1)
    8. # define the model
    9. model = KNeighborsRegressor()
    10. # fit the model
    11. model.fit(X, y)
    12. # perform permutation importance
    13. results = permutation_importance(model, X, y, scoring='neg_mean_squared_error')
    14. # get importance
    15. importance = results.importances_mean
    16. # summarize feature importance
    17. for i,v in enumerate(importance):
    18. print('Feature: %0d, Score: %.5f' % (i,v))
    19. # plot feature importance
    20. pyplot.bar([x for x in range(len(importance))], importance)
    21. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的两个或三个可能对预测很重要。

    1. Feature: 0, Score: 175.52007
    2. Feature: 1, Score: 345.80170
    3. Feature: 2, Score: 126.60578
    4. Feature: 3, Score: 95.90081
    5. Feature: 4, Score: 9666.16446
    6. Feature: 5, Score: 8036.79033
    7. Feature: 6, Score: 929.58517
    8. Feature: 7, Score: 139.67416
    9. Feature: 8, Score: 132.06246
    10. Feature: 9, Score: 84.94768

    然后为特征重要性得分创建条形图。

    5.2随机排序(分类)特征重要性

    下面列出了拟合KNeighborsClassifier并且计算特征重要性得分的完整示例。

    1. # permutation feature importance with knn for classification
    2. from sklearn.datasets import make_classification
    3. from sklearn.neighbors import KNeighborsClassifier
    4. from sklearn.inspection import permutation_importance
    5. from matplotlib import pyplot
    6. # define dataset
    7. X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, n_redundant=5, random_state=1)
    8. # define the model
    9. model = KNeighborsClassifier()
    10. # fit the model
    11. model.fit(X, y)
    12. # perform permutation importance
    13. results = permutation_importance(model, X, y, scoring='accuracy')
    14. # get importance
    15. importance = results.importances_mean
    16. # summarize feature importance
    17. for i,v in enumerate(importance):
    18. print('Feature: %0d, Score: %.5f' % (i,v))
    19. # plot feature importance
    20. pyplot.bar([x for x in range(len(importance))], importance)
    21. pyplot.show()

    运行示例,拟合模型,然后输出每个特征的系数值。

    结果表明,这十个特征中的两个或三个可能对预测很重要。

    1. Feature: 0, Score: 0.04760
    2. Feature: 1, Score: 0.06680
    3. Feature: 2, Score: 0.05240
    4. Feature: 3, Score: 0.09300
    5. Feature: 4, Score: 0.05140
    6. Feature: 5, Score: 0.05520
    7. Feature: 6, Score: 0.07920
    8. Feature: 7, Score: 0.05560
    9. Feature: 8, Score: 0.05620
    10. Feature: 9, Score: 0.03080

    然后为特征重要性得分创建条形图。

    总结

    在本教程中,您知道了在Python机器学习中的特征重要性得分。

    具体来说,您了解到:

    • 特征重要性在预测建模问题中的作用
    • 如何从线性模型和决策树中计算和查看特征重要性
    • 如何计算和查看随机排序特征重要性得分
    展开全文
  • 随机森林计算特征重要性The feature importance describes which features are relevant. It can help with a better understanding of the solved problem and sometimes lead to model improvement by utilizing ...

    随机森林计算特征重要性

    The feature importance describes which features are relevant. It can help with a better understanding of the solved problem and sometimes lead to model improvement by utilizing feature selection. In this post, I will present 3 ways (with code) to compute feature importance for the Random Forest algorithm from scikit-learn package (in Python).

    功能重要性描述了哪些功能是相关的。 它可以帮助您更好地了解已解决的问题,有时还可以利用特征选择来改进模型。 在这篇文章中,我将介绍3种方法(使用代码),以scikit-learn包(在Python中)为随机森林算法计算功能重要性。

    内置随机森林重要性 (Built-in Random Forest Importance)

    The Random Forest algorithm has built-in feature importance which can be computed in two ways:

    随机森林算法具有内置的特征重要性,可以通过两种方式计算:

    • Gini importance (or mean decrease impurity), which is computed from the Random Forest structure. Let’s look at how the Random Forest is constructed. It is a set of Decision Trees. Each Decision Tree is a set of internal nodes and leaves. In the internal node, the selected feature is used to make a decision on how to divide the data set into two separate sets with similar responses within. The features for internal nodes are selected with some criterion, which for classification tasks can be Gini impurity or information gain, and for regression is variance reduction. We can measure how each feature decreases the impurity of the split (the feature with the highest decrease is selected for internal node). For each feature, we can collect how on average it decreases the impurity. The average over all trees in the forest is the measure of the feature importance. This method is available in scikit-learn the implementation of the Random Forest (for both classifier and regressor). It is worth mentioning that in this method, we should look at the relative values of the computed importances. This biggest advantage of this method is the speed of computation - all needed values are computed during the Radom Forest training. The drawback of the method is a tendency to prefer (select as important) numerical features and categorical features with high cardinality. What is more, in the case of correlated features it can select one of the features and neglect the importance of the second one (which can lead to wrong conclusions).

      基尼重要性 (或平均减少杂质),由随机森林结构计算得出。 让我们看看随机森林是如何构建的。 它是一组决策树。 每个决策树都是一组内部节点和叶子。 在内部节点中,所选功能用于决定如何将数据集分为两个单独的集合,并在其中进行类似的响应。 内部节点的特征按某些标准选择,对于分类任务可以是基尼杂质或信息增益,对于回归是方差减少。 我们可以测量每个特征如何减少分割的杂质(为内部节点选择具有最大减少的特征)。 对于每个功能,我们可以收集平均如何减少杂质。 森林中所有树木的平均值是特征重要性的度量。 scikit-learn可以使用此方法来scikit-learn随机森林的实现 (对于分类器和回归器)。 值得一提的是,在这种方法中,我们应该查看计算出的重要性的相对值。 此方法的最大优点是计算速度-在Radom Forest训练期间计算所有需要的值。 该方法的缺点是倾向于倾向于(选择作为重要的)具有高基数的数字特征和分类特征。 而且,在具有相关特征的情况下,它可以选择特征之一,而忽略第二个特征的重要性(这可能导致错误的结论)。

    • Mean Decrease Accuracy — is a method of computing the feature importance on permuted out-of-bag (OOB) samples based on a mean decrease in the accuracy. This method is not implemented in the scikit-learn package. The very similar to this method is permutation-based importance described below in this post.

      平均降低准确性 -是一种基于准确性的平均降低来计算置换袋装(OOB)样本的特征重要性的方法。 scikit-learn包中未实现此方法。 与此方法非常相似的是下文中介绍的基于置换的重要性。

    I will show how to compute feature importance for the Random Forest with scikit-learn package and Boston dataset (house price regression task).

    我将展示如何使用scikit-learn软件包和Boston数据集(房价回归任务)来计算随机森林的特征重要性。

    # Let's load the packagesimport numpy as npimport pandas as pdfrom sklearn.datasets import load_bostonfrom sklearn.model_selection import train_test_splitfrom sklearn.ensemble import RandomForestRegressorfrom sklearn.inspection import permutation_importanceimport shapfrom matplotlib import pyplot as plt
    plt.rcParams.update({'figure.figsize': (12.0, 8.0)})
    plt.rcParams.update({'font.size': 14})

    Load the data set and split for training and testing.

    加载数据集并拆分以进行训练和测试。

    boston = load_boston()
    X = pd.DataFrame(boston.data, columns=boston.feature_names)
    y = boston.target
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=12)

    Fit the Random Forest Regressor with 100 Decision Trees:

    使随机森林回归器具有100个决策树:

    rf = RandomForestRegressor(n_estimators=100)
    rf.fit(X_train, y_train)

    To get the feature importances from the Random Forest model use the feature_importances_ argument:

    要从“随机森林”模型中获取要素重要性,请使用feature_importances_参数:

    rf.feature_importances_array([0.04054781, 0.00149293, 0.00576977, 0.00071805, 0.02944643,
    0.25261155, 0.01969354, 0.05781783, 0.0050257 , 0.01615872,
    0.01066154, 0.01185997, 0.54819617])

    Let’s plot the importances (chart will be easier to interpret than values).

    让我们来画出重要性(图表比值更容易解释)。

    plt.barh(boston.feature_names, rf.feature_importances_)

    To have an even better chart, let’s sort the features, and plot again:

    为了获得更好的图表,让我们对特征进行排序,然后再次绘图:

    sorted_idx = rf.feature_importances_.argsort()
    plt.barh(boston.feature_names[sorted_idx], rf.feature_importances_[sorted_idx])
    plt.xlabel("Random Forest Feature Importance")
    Image for post

    基于排列的重要性 (Permutation-based Importance)

    The permutation-based importance can be used to overcome drawbacks of default feature importance computed with mean impurity decrease. It is implemented in scikit-learn as permutation_importance method. As arguments it requires trained model (can be any model compatible with scikit-learn API) and validation (test data). This method will randomly shuffle each feature and compute the change in the model's performance. The features which impact the performance the most are the most important one.

    基于置换的重要性可用于克服使用平均杂质减少计算出的默认特征重要性的缺点。 它在scikit-learn作为permutation_importance方法实现。 作为参数,它需要训练有素的模型(可以是与scikit-learn API兼容的任何模型)和验证(测试数据)。 该方法将随机地对每个功能进行随机排序,并计算模型性能的变化。 最影响性能的功能是最重要的功能。

    Permutation importance can be easily computed:

    排列重要性很容易计算:

    perm_importance = permutation_importance(rf, X_test, y_test)

    To plot the importance:

    绘制重要性:

    sorted_idx = perm_importance.importances_mean.argsort()
    plt.barh(boston.feature_names[sorted_idx], perm_importance.importances_mean[sorted_idx])
    plt.xlabel("Permutation Importance")
    Image for post

    The permutation-based importance is computationally expensive. The permutation-based method can have problems with highly-correlated features, it can report them as unimportant.

    基于排列的重要性在计算上很昂贵。 基于置换的方法可能会遇到功能高度相关的问题,可以将其报告为不重要的。

    从SHAP值计算重要性 (Compute Importance from SHAP Values)

    The SHAP interpretation can be used (it is model-agnostic) to compute the feature importances from the Random Forest. It is using the Shapley values from game theory to estimate how does each feature contributes to the prediction. It can be easily installed ( pip install shap) and used with scikit-learn Random Forest:

    可以使用SHAP解释(与模型无关)来计算随机森林中的特征重要性。 它使用博弈论中的Shapley值来估计每个特征如何对预测做出贡献。 它可以轻松安装( pip install shap )并与scikit-learn随机森林一起使用:

    explainer = shap.TreeExplainer(rf)
    shap_values = explainer.shap_values(X_test)

    To plot feature importance as the horizontal bar plot we need to use summary_plot the method:

    要将要素重要性绘制为水平条形图,我们需要使用summary_plot方法:

    shap.summary_plot(shap_values, X_test, plot_type="bar")
    Image for post

    The feature importance can be plotted with more details, showing the feature value:

    可以使用更多细节绘制特征重要性,以显示特征值:

    shap.summary_plot(shap_values, X_test)
    Image for post

    The computing feature importances with SHAP can be computationally expensive. However, it can provide more information like decision plots or dependence plots.

    SHAP对计算功能的重要性在计算上可能很昂贵。 但是,它可以提供更多信息,例如决策图或依赖图。

    摘要 (Summary)

    The 3 ways to compute the feature importance for the scikit-learn Random Forest was presented:

    提出了三种计算scikit-learn随机森林特征重要性的方法:

    • built-in feature importance

      内置功能的重要性
    • permutation-based importance

      基于置换的重要性
    • computed with SHAP values

      用SHAP值计算

    In my opinion, it is always good to check all methods and compare the results. I’m using permutation and SHAP based methods in MLJAR’s AutoML open-source package mljar-supervised. I'm using them because they are model-agnostic and works well with algorithms not from scikit-learn: Xgboost, Neural Networks (keras+tensorflow), LigthGBM, CatBoost.

    我认为,检查所有方法并比较结果总是好的。 我在MLJAR的AutoML开源软件包mljar-supervised使用基于置换和SHAP的方法。 我之所以使用它们,是因为它们与模型无关,并且可以很好地与scikit-learn算法配合使用:Xgboost,神经网络(keras + tensorflow),LigthGBM,CatBoost。

    重要笔记 (Important Notes)

    • The more accurate model is, the more trustworthy computed importance is.

      模型越准确,计算出的重要性就越值得信赖。
    • The computed importances describe how important features are for the machine learning model. It is an approximation of how important features are in the data

      计算出的重要性描述了机器学习模型的重要特征。 这是数据中重要特征的近似值

    The mljar-supervised is an open-source Automated Machine Learning (AutoML) Python package that works with tabular data. It is designed to save time for a data scientist. It abstracts the common way to preprocess the data, construct the machine learning models, and perform hyper-parameters tuning to find the best model. It is no black-box as you can see exactly how the ML pipeline is constructed (with a detailed Markdown report for each ML model).

    mljar监督的是可处理表格数据的开源自动机器学习(AutoML)Python软件包。 它旨在为数据科学家节省时间。 它抽象了预处理数据,构建机器学习模型以及执行超参数调整以找到最佳模型的通用方法。 这不是黑盒子,因为您可以确切地看到ML管道的构造方式(每个ML模型都有详细的Markdown报告)。

    Image for post
    The example report generated with a mljar-supervised AutoML package.
    使用mljar监督的AutoML软件包生成的示例报告。

    Originally published at https://mljar.com on June 29, 2020.

    最初于 2020年6月29日 发布在 https://mljar.com 上。

    翻译自: https://towardsdatascience.com/the-3-ways-to-compute-feature-importance-in-the-random-forest-96c86b49e6d4

    随机森林计算特征重要性

    展开全文
  • 在使用GBDT、RF、Xgboost等树类模型建模时,往往可以通过 feature_importance 来返回特征重要性,各模型输出特征重要性的原理与方法 一 计算特征重要性方法 首先,目前计算特征重要性计算方法主要有两个方面: ...

    在使用GBDT、RF、Xgboost等树类模型建模时,往往可以通过 feature_importance 来返回特征重要性,各模型输出特征重要性的原理与方法

    一 计算特征重要性方法

    首先,目前计算特征重要性计算方法主要有两个方面:

    1.1 训练过程中计算

    训练过程中通过记录特征的分裂总次数、总/平均信息增益来对特征重要性进行量化。例如实际工程中我们会用特征在整个GBDT、XgBoost里面被使用的次数或者带来的总/平均信息增益来给特征重要度打分,最后进行排序。由于本身Ensemble模型在选择特征分裂时带有一定随机性,一般会跑多个模型然后把特征重要性求平均后排序。

    作为单个决策树模型,在模型建立时实际上是寻找到某个特征合适的分割点。这个信息可以作为衡量所有特征重要性的一个指标。

    基本思路如下:
    如果一个特征被选为分割点的次数越多,那么这个特征的重要性就越强。这个理念可以被推广到集成算法中,只要将每棵树的特征重要性进行简单的平均即可。

    分别根据特征1和特征4进行分割,显然x1出现的次数最多,这里不考虑先分割和后分割的情况,只考虑每次分割属性出现的次数。

    计算得:
    x1的特征重要度:出现在2棵树上,两棵树一共分裂了6次,x1出现了3次。
    x1特征重要度 = 3/6 = 1/2
    x2的特征重要度= 4/6 = 2/3
    x3的特征重要度= 3/6 = 1/2


    x4的特征重要度: 出现在1棵树上,一个树分裂了3次,x4出现了1次。
    x4的特征重要度= 1/3

    根据特征重要度进行特征选择。

     

    1.2 训练后使用OOB(Out of Bag)数据计算

    第二种方式是训练好模型之后,用Out of Bag(或称Test)数据进行特征重要性的量化计算。具体来说,先用训练好的模型对OOB数据进行打分,计算出AUC或其他业务定义的评估指标;接着对OOB数据中的每个特征:

    (1)随机shuffle当前特征的取值;

    (2)重新对当前数据进行打分,计算评估指标;

    (3)计算指标变化率

    按照上面方式,对每个特征都会得到一个变化率,最后按照变化率排序来量化特征重要性。

    延伸到 DNN 对特征重要性判定:

    DNN不像Boosting这类模型那样存在所谓的分裂次数与信息增益,就需要使用第二种方式,对每个特征进行随机shuffle,观察模型指标的变化,最后按照变化率进行排序。比如AUC下滑率,下滑的越多说明当前这个指标越重要。当然,实际操作中需要结合业务经验先指定一个候选变量池,对这部分变量计算重要度,不然计算开销太大。

     

    二. 树模型特征重要性判定

    2.1 Random Foreast

    • 袋外数据错误率(可参考OOB特征选择方法)
    • 基尼指数(和GBDT的方法相同)

    随机森林特征重要性评定可参考:https://blog.csdn.net/zjuPeco/article/details/77371645?locationNum=7&fps=1

    2.2 GBDT

    基尼指数

    在sklearn中,GBDT和RF的特征重要性计算方法是相同的,都是基于单棵树计算每个特征的重要性,探究每个特征在每棵树上做了多少的贡献,再取个平均值。 


    2.3 XGBoost

    xgboost实现中Booster类get_score方法输出特征重要性,其中importance_type参数支持三种特征重要性的计算方法:

    • importance_type=weight(默认):the number of times a feature is used to split the data across all trees. 特征重要性使用特征在所有树中作为划分属性的次数。
    • importance_type=gain:is the average gain of splits which use the feature. 特征重要性使用特征在作为划分属性带来的平均增益。
    • importance_type=cover:is the average coverage of splits which use the feature where coverage is defined as the number of samples affected by the split. 使用该特作为分割影响的平均样本数。——可以理解为被分到该节点的样本的二阶导数之和,而特征度量的标准就是平均的coverage值。
    • importance_type=total_gain: the total gain across all splits the feature is used in.
    • importance_type=total_cover: the total coverage across all splits the feature is used in

    cover 的解释有点晦涩,在[R-package/man/xgb.plot.tree.Rd]有比较详尽的解释:

    (https://github.com/dmlc/xgboost/blob/f5659e17d5200bd7471a2e735177a81cb8d3012b/R-package/man/xgb.plot.tree.Rd)

    the sum of second order gradient of training data classified to the leaf, if it is square loss, this simply corresponds to the number of instances in that branch. Deeper in the tree a node is, lower this metric will be。实际上coverage可以理解为被分到该节点的样本的二阶导数之和,而特征度量的标准就是平均的coverage值。

     

    下面就结合这张图,解释下各指标含义: 

    1. weight:  {‘f0’: 1, ‘f1’: 2}
    在所有树中,某特征被用来分裂节点的次数,在本例中,可见分裂第1个节点时用到f0,分裂第2,3个节点时用到f1,所以weight_f0 = 1, weight_f1 = 2


    2. total_cover:  {‘f0’: 10.0, ‘f1’: 8.0}
    第1个节点,f0被用来对所有10个样例进行分裂,之后的节点中f0没再被用到,所以f0的total_cover为10.0,此时f0 >= 0.855563045的样例有5个,落入右子树;
    第2个节点,f1被用来对上面落入右子树的5个样例进行分裂,其中f1 >= -0.178257734的样例有3个,落入右子树;
    第3个节点,f1被用来对上面落入右子树的3个样例进行分裂。
    总结起来,f0在第1个节点分裂了10个样例,所以total_cover_f0 = 10,f1在第2、3个节点分别用于分裂5、3个样例,所以total_cover_f1 = 5 + 3 = 8。total_cover表示在所有树中,某特征在每次分裂节点时处理(覆盖)的所有样例的数量。


    3. cover:  {‘f0’: 10.0, ‘f1’: 4.0}
    cover = total_cover / weight,在本例中,cover_f0 = 10 / 1,cover_f1 = 8 / 2 = 4.


    4. total_gain:  {‘f0’: 0.265151441, ‘f1’: 0.75000003}
    在所有树中,某特征在每次分裂节点时带来的总增益,如果用熵或基尼不纯衡量分裂前后的信息量分别为i0和i1,则增益为(i0 - i1)。


    5. gain:  {‘f0’: 0.265151441, ‘f1’: 0.375000015}

    gain就是特征用于分割的平均增益 ,gain = total_gain / weight,在本例中,gain_f0 = 0.265151441 / 1,gain_f1 = 75000003 / 2 = 375000015.

    在平时的使用中,多用total_gain来对特征重要性进行排序。

     

    2.4 Lightgbm

    split:result contains numbers of times the feature is used in a mode (特征重要性使用特征在所有树中作为划分属性的次数)
    gain:result contains total gains of splits which use the feature (使用该特征作为分割带来的总增益)


     

    参考文献

    1. https://blog.csdn.net/tinkle181129/article/details/80231871
    2. https://blog.csdn.net/lz_peter/article/details/85010931
    展开全文
  • XGBoost学习(六):输出特征重要性以及筛选特征

    千次阅读 多人点赞 2020-09-03 16:03:17
    XGBoost输出特征重要性以及筛选特征 1,梯度提升算法是如何计算特征重要性的? 使用梯度提升算法的好处是在提升树被创建后,可以相对直接地得到每个属性的重要性得分。一般来说,重要性分数,衡量了特征在模型中的...

    XGBoost学习(一):原理
    XGBoost学习(二):安装及介绍
    XGBoost学习(三):模型详解
    XGBoost学习(四):实战
    XGBoost学习(五):参数调优
    XGBoost学习(六):输出特征重要性以及筛选特征
    完整代码及其数据

    XGBoost输出特征重要性以及筛选特征

    1,梯度提升算法是如何计算特征重要性的?

    使用梯度提升算法的好处是在提升树被创建后,可以相对直接地得到每个属性的重要性得分。一般来说,重要性分数,衡量了特征在模型中的提升决策树构建中的价值。一个属性越多的被用来在模型中构建决策树,它的重要性就相对越高。

    属性重要性是通过对数据集中的每个属性进行计算,并进行排序得到。在单个决策树中通过每个属性分裂点改进性能度量的量来计算属性重要性。由节点负责加权和记录次数,也就是说一个属性对分裂点改进性能度量越大(越靠近根节点),权值越大;被越多提升树所选择,属性越重要。性能度量可以是选择分裂节点的Gini纯度,也可以是其他度量函数。

    最终将一个属性在所有提升树中的结果进行加权求和后然后平均,得到重要性得分。

    2,绘制特征重要性

    一个已训练的Xgboost模型能够自动计算特征重要性,这些重要性得分可以通过成员变量feature_importances_得到。可以通过如下命令打印:

    print(model.feature_importances_)
    

    我们可以直接在条形图上绘制这些分数,以便获得数据集中每个特征的相对重要性的直观显示,例如:

    # plot
    pyplot.bar(range(len(model.feature_importances_)), model.feature_importances_)
    pyplot.show()
    

    我们可以通过在the Pima Indians onset of diabetes 数据集上训练XGBoost模型来演示,并从计算的特征重要性中绘制条形图。

    # plot feature importance manually
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from matplotlib import pyplot
    from sklearn.datasets import load_iris
    # load data
    dataset = load_iris()
    # split data into X and y
    X = dataset.data
    y = dataset.target
    # fit model no training data
    model = XGBClassifier()
    model.fit(X, y)
    # feature importance
    print(model.feature_importances_)
    # plot
    pyplot.bar(range(len(model.feature_importances_)), model.feature_importances_)
    pyplot.show()
    

    运行这个实例,首先输出特征重要性分数:
    [0.17941953 0.11345647 0.41556728 0.29155672]
    相对重要性条形图:
    在这里插入图片描述
      这种绘制的缺点在于,只显示了特征重要性而没有排序,可以在绘制之前对特征重要性得分进行排序。
      通过内建的绘制函数进行特征重要性得分排序后的绘制,这个函数就是plot_importance(),示例如下:

    # plot feature importance manually
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from matplotlib import pyplot
    from sklearn.datasets import load_iris
    from xgboost import plot_importance
     
    # load data
    dataset = load_iris()
    # split data into X and y
    X = dataset.data
    y = dataset.target
    # fit model no training data
    model = XGBClassifier()
    model.fit(X, y)
    # feature importance
    print(model.feature_importances_)
    # plot feature importance
     
    plot_importance(model)
    pyplot.show()
    

    示例得到条形图:
    在这里插入图片描述

    根据其在输入数组的索引,特征被自动命名为f0~f3,在问题描述中手动的将这些索引映射到名称,我们可以看到,f2具有最高的重要性,f1具有最低的重要性。

    3,根据Xgboost特征重要性得分进行特征选择

    特征重要性得分,可以用于在scikit-learn中进行特征选择。通过SelectFromModel类实现,该类采用模型并将数据集转换为具有选定特征的子集。这个类可以采取预先训练的模型,例如在整个数据集上训练的模型。然后,它可以阈值来决定选择哪些特征。当在SelectFromModel实例上调用transform()方法时,该阈值被用于在训练集和测试集上一致性选择相同特征。

    在下面的示例中,我们首先在训练集上训练xgboost模型,然后在测试上评估。使用从训练数据集计算的特征重要性,然后,将模型封装在一个SelectFromModel实例中。我们使用这个来选择训练集上的特征,用所选择的特征子集训练模型,然后在相同的特征方案下对测试集进行评估。

    # select features using threshold
    selection = SelectFromModel(model, threshold=thresh, prefit=True)
    select_X_train = selection.transform(X_train)
    # train model
    selection_model = XGBClassifier()
    selection_model.fit(select_X_train, y_train)
    # eval model
    select_X_test = selection.transform(X_test)
    y_pred = selection_model.predict(select_X_test)
    

    我们可以通过测试多个阈值,来从特征重要性中选择特征。具体而言,每个输入变量的特征重要性,本质上允许我们通过重要性来测试每个特征子集。

    完整代码如下:

    # plot feature importance manually
    import numpy as np
    from xgboost import XGBClassifier
    from matplotlib import pyplot
    from sklearn.datasets import load_iris
    from xgboost import plot_importance
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.feature_selection import SelectFromModel
     
    # load data
    dataset = load_iris()
    # split data into X and y
    X = dataset.data
    y = dataset.target
     
    # split data into train and test sets
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.33,random_state=7)
     
    # fit model no training data
    model = XGBClassifier()
    model.fit(X_train, y_train)
    # feature importance
    print(model.feature_importances_)
     
    # make predictions for test data and evaluate
    y_pred = model.predict(X_test)
    predictions = [round(value) for value in y_pred]
    accuracy = accuracy_score(y_test,predictions)
    print("Accuracy:%.2f%%"%(accuracy*100.0))
     
    #fit model using each importance as a threshold
    thresholds = np.sort(model.feature_importances_)
    for thresh in thresholds:
        # select features using threshold
        selection = SelectFromModel(model,threshold=thresh,prefit=True )
        select_X_train = selection.transform(X_train)
        # train model
        selection_model = XGBClassifier()
        selection_model.fit(select_X_train, y_train)
        # eval model
        select_X_test = selection.transform(X_test)
        y_pred = selection_model.predict(select_X_test)
        predictions = [round(value) for value in y_pred]
        accuracy = accuracy_score(y_test,predictions)
        print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (thresh, select_X_train.shape[1], accuracy * 100.0))
    

    运行示例,得到输出:
    [0.20993228 0.09029345 0.54176074 0.15801354]
    Accuracy:92.00%
    Thresh=0.090, n=4, Accuracy: 92.00%
    Thresh=0.158, n=3, Accuracy: 92.00%
    Thresh=0.210, n=2, Accuracy: 86.00%
    Thresh=0.542, n=1, Accuracy: 90.00%
    我们可以看到,模型的性能通常随着所选择的特征的数量减少,在这一问题上,可以对测试集准确率和模型复杂度做一个权衡,例如选择三个特征,接受准确率为92%,这可能是对这样一个小数据集的清洗,但是对于更大的数据集和使用交叉验证作为模型评估方案可能是更有用的策略。

    4,网格搜索

    代码1:

    from sklearn.model_selection import GridSearchCV
    tuned_parameters= [{'n_estimators':[100,200,500],
                      'max_depth':[3,5,7], ##range(3,10,2)
                      'learning_rate':[0.5, 1.0],
                      'subsample':[0.75,0.8,0.85,0.9]
                      }]
    tuned_parameters= [{'n_estimators':[100,200,500,1000]
                      }]
    clf = GridSearchCV(XGBClassifier(silent=0,nthread=4,learning_rate= 0.5,min_child_weight=1, max_depth=3,gamma=0,subsample=1,colsample_bytree=1,reg_lambda=1,seed=1000), param_grid=tuned_parameters,scoring='roc_auc',n_jobs=4,iid=False,cv=5) 
    clf.fit(X_train, y_train)
    ##clf.grid_scores_, clf.best_params_, clf.best_score_
    print(clf.best_params_)
    y_true, y_pred = y_test, clf.predict(X_test)
    print"Accuracy : %.4g" % metrics.accuracy_score(y_true, y_pred)
    y_proba=clf.predict_proba(X_test)[:,1]
    print "AUC Score (Train): %f" % metrics.roc_auc_score(y_true, y_proba)   
    

    代码2:

    from sklearn.model_selection import GridSearchCV
    parameters= [{'learning_rate':[0.01,0.1,0.3],'n_estimators':[1000,1200,1500,2000,2500]}]
    clf = GridSearchCV(XGBClassifier(
                 max_depth=3,
                 min_child_weight=1,
                 gamma=0.5,
                 subsample=0.6,
                 colsample_bytree=0.6,
                 objective= 'binary:logistic', #逻辑回归损失函数
                 scale_pos_weight=1,
                 reg_alpha=0,
                 reg_lambda=1,
                 seed=27
                ),
                param_grid=parameters,scoring='roc_auc') 
    clf.fit(X_train, y_train)
    print(clf.best_params_) 
    y_pre= clf.predict(X_test)
    y_pro= clf.predict_proba(X_test)[:,1]
    print "AUC Score : %f" % metrics.roc_auc_score(y_test, y_pro)
    print"Accuracy : %.4g" % metrics.accuracy_score(y_test, y_pre)
    

    输出特征重要性:

    import pandas as pd
    import matplotlib.pylab as plt
    feat_imp = pd.Series(clf.booster().get_fscore()).sort_values(ascending=False)
    feat_imp.plot(kind='bar', title='Feature Importances')
    plt.ylabel('Feature Importance Score')
    plt.show()
    

    补充:关于随机种子——random_state

    random_state是一个随机种子,是在任意带有随机性的类或者函数里作为参数来控制随机模式。random_state取某一个值的时候,也就确定了一种规则。
    random_state可以用于很多函数,比如训练集测试集的划分;构建决策树;构建随机森林

    1,划分训练集和测试集的类train_test_split

    随机数种子控制每次划分训练集和测试集的模式,其取值不变时划分得到的结果一模一样,其值改变时,划分得到的结果不同。若不设置此参数,则函数会自动选择一种随机模式,得到的结果也就不同。

    2,构建决策树的函数

    clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30,splitter="random")
    

    其取值不变时,用相同的训练集建树得到的结果一模一样,对测试集的预测结果也是一样的
    其取值改变时,得到的结果不同;
    若不设置此参数(即设置为None),则函数会自动选择一种随机模式,每次得到的结果也就不同,可能稍微有所波动。

    3,构建随机森林

    clf = RandomForestClassifier(random_state=0)
    

    其取值不变时,用相同的训练集建树得到的结果一模一样,对测试集的预测结果也是一样的
    其取值改变时,得到的结果不同;
    若不设置此参数(即设置为None),则函数会自动选择一种随机模式,每次得到的结果也就不同,可能稍微有所波动。

    4,总结

    在需要设置random_state的地方给其赋值,当多次运行此段代码得到完全一样的结果,别人运行代码也可以复现你的过程。若不设置此参数则会随机选择一个种子,执行结果也会因此不同。虽然可以对random_state进行调参,但是调参后再训练集上表现好的模型未必在陌生训练集上表现好,所以一般会随便选择一个random_state的值作为参数。
    对于那些本质上是随机的过程,我们有必要控制随机的状态,这样才能重复的展现相同的结果。如果对随机状态不加控制,那么实验的结果就无法固定,而是随机的显示。
    其实random_state 与 random seed作用是相同的,下面我们通过 random seed来学习一下 random_state:
    在这里插入图片描述
    第一段代码和第二段代码完全相同,在1~100中取10个随机数,都没有设置 random seed,它每次取的结果就不太,它的随机数种子与当前系统的时间有关。
    第三段代码和第四段代码设置了相同的 random seed(123),他们取的随机数就完全相同,你多运行几次也是这样。
    第五段代码设置了 random seed(456),但是与之前设置的不同,于是运行取随机数的结果也不同。

    展开全文
  • 特征重要性评估及筛选

    千次阅读 2020-03-04 17:55:21
    sklearn中特征重要性的计算方法, 基于重要性来进行特征选择
  • 用xgboost模型对特征重要性进行排序

    万次阅读 多人点赞 2018-08-12 21:08:21
    用xgboost模型对特征重要性进行排序 在这篇文章中,你将会学习到: xgboost对预测模型特征重要性排序的原理(即为什么xgboost可以对预测模型特征重要性进行排序)。 如何绘制xgboost模型得到的特征重要性条形图。...
  • 在建立模型之前,特征重要性能够帮助训练模型,防止过拟合,提升模型的RUC效果。 建立模型之后,特征重要性能够增强模型(集成模型 非深度学习模型)的可解释性,帮助建立模型信任、做出现实意义上的决策。 建模前...
  •   2019-02-12 23:53:35 ...通常,除了想知道我们的机器学习模型的房价预测是什么之外,我们还想知道为什么它是这么高/低,以及哪些特征在确定预测时最重要。另一个例子是预测客户流失 - 拥有一个...
  • 使用诸如梯度增强之类的决策树方法的集成的好处是,它们可以从训练有素的预测模型中自动提供特征重要性的估计。在本文中,您将发现如何使用Python中的XGBoost库来估计特征对于预测性建模问...
  • 特征重要性与shap值

    千次阅读 2020-07-23 19:42:30
    在模型的训练过程中,往往会需求更加优异的模型性能指标如准确率、召回等,但在实际生产中,随着模型上线使用产生衰减,又需要快速定位问题进行修复,因此了解模型如何运作、哪些特征起到了关键作用有着重要意义。...
  • 机器学习 | 特征重要性判断

    千次阅读 2019-05-12 20:34:13
    聊聊feature_importances_1 背景2 ...在运用树模型建模的时候,常用的一个sklearn的子库就是看特征重要性,也就是feature_importances_,下面将从原理和Python代码实现两个角度来聊一聊! 2 原理 待补充 3 Python...
  • LightGBM特征重要性画图

    千次阅读 2021-04-01 10:10:49
    lightgbm官方文档 前言 基于树的模型可以用来评估特征重要性。 在本博客中,我将使用LightGBM中的GBDT模型来评估特性重要性的步骤。 LightGBM是由微软发布的高精度和高速度梯度增强框架(一些测试表明LightGBM...
  • 特征重要性排序--Permutation Importance

    千次阅读 2021-03-30 13:58:31
    特征重要性排序–Permutation Importance 参考:Permutation Importance | Kaggle 相比于其他衡量特征重要性的方法,Permutation Importance的优点: 计算量低 广泛使用和容易理解 与我们要测量特征重要性的属性...
  • 前言 在使用GBDT、RF、Xgboost等树类模型建模时,往往可以通过feature_importance 来返回特征重要性,本文以随机森林为例介绍其原理与实现。[ 链接:机器学习的特征重要性究竟是怎么算的] 数据:美国某公司的共享...
  • 利用随机森林对特征重要性进行评估

    万次阅读 多人点赞 2017-08-18 16:22:48
    随机森林是以决策树为基学习器的集成学习算法。随机森林非常简单,易于实现,计算开销也很小,更令人惊奇的是它在分类和回归上表现出了十分惊人的性能,因此,...本文是对随机森林如何用在特征选择上做一个简单的介绍。
  • 1.决策树使用基尼系数(GI)和信息增益(IG)为决策树计算特征重要性。(1)信息增益(information gain)假定当前样本集合D中第k类样本所占我的比例为,则D的信息熵为 (1)的值越小,则D的纯度越高。假定离散属性a...
  • 树模型特征重要性评估方法

    千次阅读 2018-05-07 21:28:33
    前言 在特征的选择过程中,如果学习器...各种模型的特征重要性计算 Random Forests 袋外数据错误率评估 RF的数据是boostrap的有放回采样,形成了袋外数据。因此可以采用袋外数据(OOB)错误率进行特征重要...
  • 随机森林评估特征重要性

    千次阅读 2019-11-01 10:24:00
    随机森林(RF)简介 只要了解决策树的算法,那么随机森林是相当容易理解的。...2)利用这d个特征分别对样本集进行划分,找到最佳的划分特征(可用基尼系数、增益率或者信息增益判别) 3、重复步骤1...
  • 我们都知道在常见的逻辑回归模型中,每个特征对应一个模型参数wiw_{i}wi​,该参数约大,那么该特征对模型预测结果的影响就会越大,我们就说该特征就越重要,因此LR模型的特征重要性评估方式就是wiw_{i}wi​的大小,...
  • 根据特征重要性进行特征选择

    千次阅读 2018-06-02 15:36:26
    对钓鱼网页特征进行提取 使用随机森林进行分类 分类结果不够准确 前几天看书看到了根据特征重要性进行特征筛选 今天拿来试一下原本选择了11个特征进行了特征提取 feature_names = ['img_num', 'form_num', 'input...
  • sklean.tree.DicisionTreeClassifier类中的feature_importances_属性返回的是特征重要性,feature_importances_越高代表特征越重要,scikit-learn官方文档1中的解释如下: The importance of a feature is ...
  • lgbm输出特征重要性

    千次阅读 2019-08-13 15:44:18
    lgb_clf = lgb....然而特征重要性的结果并不是很可靠,也不能反应特征相互组合对logloss的影响。故我们使用warpper的方式来进行特征选择。将前向搜索、后向搜索和随机搜索进行组合筛选出最终特征。 Ref: ...
  • 树模型特征重要性计算方法总结

    千次阅读 2019-04-14 13:03:56
    最近在复习特征重要性时候,考虑到我们在使用GBDT、RF、Xgboost等树类模型建模时,往往可以通过feature_importance 来返回特征重要性,下面收集整理了一下各模型输出特征重要性的原理与方法; 1. 计算特征重要性...
  • LR模型特征重要性排序

    千次阅读 2019-09-17 23:10:02
    1.特征重要性的意义 LR模型也就是逻辑回归模型,作为一个简单的常用的模型,其有非常多的有点,除了模型简单,容易实现分布式,还有一个重要的优点就是模型的可解释性非常好。因为每个特征都对应一个模型参数wiw_{i}...
  • 逻辑回归特征重要性查看

    千次阅读 2020-01-10 19:26:23
    逻辑回归特征重要性查看 LR模型也就是逻辑回归模型,作为一个简单的常用的模型,其有非常多的优点,除了模型简单,容易实现分布式, 还有一个重要的优点就是模型的可解释性非常好。因为每个特征都对应一个模型参数wi...
  • 在复习特征重要性时候,考虑到我们在使用GBDT ,RF,Xgboost 等树类模型建模时,往往可以通过feature_importance 来返回特征重要性,一下是各模型输出特征重要性的原理和方法。 1 计算特征重要性方法 1-1 训练过程...
  • 用xgboost获取特征重要性原理及实践

    千次阅读 2019-04-13 17:39:49
    1.xgboost对特征重要性排序的原理 xgboost根据结构分数的增益情况计算出来选择哪个特征作为分割点,而某个特征的重要性就是它在所有树中出现的次数之和。也就是说一个属性越多的被用来在模型中构建决策树,它的重要性...
  • 随机森林对特征重要性排序

    千次阅读 2021-02-28 11:55:38
    two methods: 1.Mean decrease impurity不纯度降低 大概是对于每颗树,按照impurity(gini /entropy /information gain)给特征排序,然后整个森林取平均。...(2)当存在相关特征时,一个特征被选择后,与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 482,118
精华内容 192,847
关键字:

特征重要性