精华内容
下载资源
问答
  • 资料参考: 1. Evaluate Feature Importance using Tree-based Model 2. lgbm.fi.plot: LightGBM Feature Importance Plotting 3. lightgbm官方文档 前言 基于树...

    转载于:https://blog.csdn.net/m0_37477175/article/details/80567010

    资料参考:
    1. Evaluate Feature Importance using Tree-based Model
    2. lgbm.fi.plot: LightGBM Feature Importance Plotting
    3. lightgbm官方文档

    前言

    基于树的模型可以用来评估特征的重要性。 在本博客中,我将使用LightGBM中的GBDT模型来评估特性重要性的步骤。 LightGBM是由微软发布的高精度和高速度梯度增强框架(一些测试表明LightGBM可以产生与XGBoost一样的准确预测,但速度可以提高25倍)。

    首先,我们导入所需的软件包:用于数据预处理的pandas,用于GBDT模型的LightGBM以及用于构建功能重要性条形图的matplotlib。

    import pandas as pd
    import matplotlib.pylab as plt
    import lightgbm as lgb
    • 1
    • 2
    • 3

    然后,我们需要加载和预处理训练数据。 在这个例子中,我们使用预测性维护数据集。

    # read data
    train = pd.read_csv('E:\Data\predicitivemaintance_processed.csv')
    

    # drop the columns that are not used for the model
    train = train.drop([‘Date’, ‘FailureDate’],axis=1)

    # set the target column
    target = ‘FailNextWeek’

    # One-hot encoding
    feature_categorical = [‘Model’]
    train = pd.get_dummies(train, columns=feature_categorical)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    接下来,我们用训练数据训练GBDT模型:

    lgb_params = {
        'boosting_type': 'gbdt',
        'objective': 'binary',
        'num_leaves': 30,
        'num_round': 360,
        'max_depth':8,
        'learning_rate': 0.01,
        'feature_fraction': 0.5,
        'bagging_fraction': 0.8,
        'bagging_freq': 12
    }
    lgb_train = lgb.Dataset(train.drop(target, 1), train[target])
    model = lgb.train(lgb_params, lgb_train)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    模型训练完成后,我们可以调用训练模型的plot_importance函数来获取特征的重要性。

    plt.figure(figsize=(12,6))
    lgb.plot_importance(model, max_num_features=30)
    plt.title("Featurertances")
    plt.show()
    • 1
    • 2
    • 3
    • 4

    这里写图片描述

    保存feature importance

    booster = model.booster_
    importance = booster.feature_importance(importance_type='split')
    feature_name = booster.feature_name()
    # for (feature_name,importance) in zip(feature_name,importance):
    #     print (feature_name,importance) 
    feature_importance = pd.DataFrame({'feature_name':feature_name,'importance':importance} )
    feature_importance.to_csv('feature_importance.csv',index=False)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    展开全文
  • lightgbm 特征重要性选择 / 看所有特征哪个重要

    万次阅读 热门讨论 2018-06-05 11:43:13
    print(pd.DataFrame({ 'column': feature_names, 'importance': lgb_trained_model.feature_importance(), }).sort_values(by='importance'))
    print(pd.DataFrame({
            'column': feature_names,
            'importance': lgb_trained_model.feature_importance(),
        }).sort_values(by='importance'))
    展开全文
  • LightGBM

    2021-03-24 17:53:12
    文章目录LightGBMLigthGBM与XGBoost异同点LightGBM训练快和内存消耗小的原因LGBMClassifier参数泰坦尼克号乘客生存率分析模型训练特征重要性混淆矩阵交叉验证TopN网格搜索最佳参数Mnist 手写数字识别多分类评估 ...

    LightGBM

    LigthGBM是boosting集合模型中的新进成员,由微软提供,它和XGBoost一样是对GBDT的高效实现,原理上它和GBDT及XGBoost类似,都采用损失函数的负梯度作为当前决策树的残差近似值,去拟合新的决策树。

    LigthGBM与XGBoost异同点

    • 模型精度:LightGBM和XGBoost相当。
    • 缺失值特征:XGBoost和LightGBM都可以自动处理特征缺失值。
    • 分类特征:LightGBM直接支持类别特征,XGBoost不支持类别特征,需要OneHot编码预处理。
    • 决策树生长策略:多数GBDT工具使用按层生长 (level-wise)的策略,LightGBM使用带深度限制的按叶子生长 (leaf-wise)算法。
    • 训练速度:LightGBM远快于XGBoost。
    • 内存消耗:LightGBM远小于XGBoost。

    LightGBM训练快和内存消耗小的原因

    • Histogram算法:直方图算法是替代XGBoost的预排序(pre-sorted)算法的。

    \quad预排序算法首先将样本按照特征取值排序,然后从全部特征取值中找到最优的分裂点位,该算法的候选分裂点数量与样本数量成正比。
    在这里插入图片描述

    \quad而直方图算法通过将连续特征值离散化到固定数量(如255个)的bins上,使得候选分为点位为常数个(num_bins -1)。
    在这里插入图片描述

    \quad此外,直方图算法还能够作直方图差加速。当节点分裂成两个时,右边叶子节点的直方图等于其父节点的直方图减去左边叶子节点的直方图。从而大大减少构建直方图的计算量。
    在这里插入图片描述

    • GOSS算法:Gradient-based One-Side Sampling,即基于梯度的单边采样算法

    \quadGOSS保留所有的梯度较大的实例,在梯度小的实例上使用随机采样。为了抵消对数据分布的影响,计算信息增益的时候,GOSS对小梯度的数据引入常量乘数。GOSS首先根据数据的梯度绝对值排序,选取top a个实例。然后在剩余的数据中随机采样b个实例。接着计算信息增益时为采样出的小梯度数据乘以(1-a)/b,这样算法就会更关注训练不足的实例,而不会过多改变原数据集的分布。
    在这里插入图片描述

    • EFB算法:Exclusive Feature Bundling,即互斥特征绑定算法

    \quadEFB是通过特征捆绑的方式减少特征维度(其实是降维技术)的方式,来提升计算效率。通常被捆绑的特征都是互斥的(一个特征值为零,一个特征值不为零),这样两个特征捆绑起来才不会丢失信息。如果两个特征并不是完全互斥(部分情况下两个特征都是非零值),可以用一个指标对特征不互斥程度进行衡量,称之为冲突比率,当这个值较小时,我们可以选择把不完全互斥的两个特征捆绑,而不影响最后的精度。
    在这里插入图片描述

    • 高效并行与网络通信优化
    import pandas as pd
    import numpy as np
    import scipy
    # import xgboost as xgb
    import lightgbm as lgb
    import tensorflow as tf
    import seaborn as sns
    import matplotlib.pyplot as plt
    
    # from sklearn.ensemble import RandomForestClassifier
    from sklearn.model_selection import GridSearchCV
    from sklearn.model_selection import cross_val_score
    from  sklearn import metrics 
    
    
    # from sklearn.utils import class_weight
    from sklearn.model_selection import train_test_split
    # from sklearn.metrics import roc_auc_score,precision_recall_curve
    
    # 打印行、列数量设置
    pd.set_option('display.max_columns',200)
    pd.set_option('display.max_rows',200)
    pd.set_option('display.width',200)
    
    #忽略一些版本不兼容等警告
    import warnings
    warnings.filterwarnings("ignore")
    
    # 模型参数设定
    model = lgb.LGBMClassifier(boosting_type='gbdt'
                              ,class_weight=None
                              ,colsample_bytree=1.0
                              ,importance_type='split'
                              ,learning_rate=0.1
                              ,max_depth=-1
                              ,min_child_samples=20
                              ,min_child_weight=0.001
                              ,min_split_gain=0.0
                              ,n_estimators=200
                              ,n_jobs=1
                              ,num_leaves=31
                              ,objective=None
                              ,random_state=None
                              ,reg_alpha=0.0
                              ,reg_lambda=0.0
                              ,silent=True
                              ,subsample=1.0
                              ,subsample_for_bin=200000)
    

    LGBMClassifier参数

    • boosting 或者’boost’ 或者 ‘boosting_type’: 一个字符串,给出了基学习器模型算法。可以为:

    \qquad‘gbdt’: 表示传统的梯度提升决策树。默认值为’gbdt’

    \qquad‘rf’: 表示随机森林

    \qquad‘dart’: 表示带dropout 的gbdt

    \qquad‘goss’:表示Gradient-based One-Side Sampling 的gbdt

    • colsample_bytree [default=1]:在建立树时对特征采样的比例。缺省值为1.取值范围:(0,1](0,1]。subsample, colsample_bytree = 0.8: 这个是最常见的初始值了。典型值的范围在0.5-0.9之间

    • learning_rates:每一次提升的学习率的列表

    • max_depth: 一个整数,限制了树模型的最大深度,默认值为-1。如果小于0,则表示没有限制。

    • min_data_in_leaf 或者 min_data_per_leaf 或者 min_data或者min_child_samples: 一个整数,表示一个叶子节点上包含的最少样本数量。默认值为 20

    • min_sum_hessian_in_leaf 或者 min_sum_hessian_per_leaf或者 min_sum_hessian 或者 min_hessian或者min_child_weight: 一个浮点数,表示一个叶子节点上的最小hessian 之和。(也就是叶节点样本权重之和的最小值) 默认为1e-3

    • min_split_gain 或者min_gain_to_split: 一个浮点数,表示执行切分的最小增益,默认为0

    • n_estimators 迭代次数

    • num_leaves或者num_leaf:一个整数,给出了一棵树上的叶子数。默认为 31

    • objective: 目标函数

    • lambda_l1 或者reg_alpha: 一个浮点数,表示L1正则化系数。默认为0

    • lambda_l2 或者reg_lambda: 一个浮点数,表示L2正则化系数。默认为0

    • silent=True: 训练过程是否打印日志信息

    • bagging_fraction 或者sub_row 或者 subsample:一个浮点数,取值范围为[0.0,1.0], 默认值为0。如果小于1.0,则lightgbm 会在每次迭代中随机选择部分样本来训练(非重复采样)。如0.8 表示:在每棵树训练之前选择80% 的样本(非重复采样)来训练

    • bin_construct_sample_cnt 或者 subsample_for_bin:一个整数,表示用来构建直方图的样本的数量。默认为200000。如果数据非常稀疏,则可以设置为一个更大的值,如果设置更大的值,则会提供更好的训练效果,但是会增加数据加载时间。

    • use_missing: 一个布尔值,表示是否使用缺失值功能。默认为True如果为False 则禁用缺失值功能。

    泰坦尼克号乘客生存率分析

    traindata_path = u'D:/01_Project/99_test/ML/titanic/train.csv'
    testdata_path = u'D:/01_Project/99_test/ML/titanic/test.csv'
    testresult_path = u'D:/01_Project/99_test/ML/titanic/gender_submission.csv'
    df_train = pd.read_csv(traindata_path)
    df_test = pd.read_csv(testdata_path)
    df_test['Survived'] = pd.read_csv(testresult_path)['Survived']
    data_original = pd.concat([df_train,df_test],sort=False)
    display (data_original.head(5))
    
    PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked
    0 1 0 3 Braund, Mr. Owen Harris male 22.0 1 0 A/5 21171 7.2500 NaN S
    1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1 0 PC 17599 71.2833 C85 C
    2 3 1 3 Heikkinen, Miss. Laina female 26.0 0 0 STON/O2. 3101282 7.9250 NaN S
    3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1 0 113803 53.1000 C123 S
    4 5 0 3 Allen, Mr. William Henry male 35.0 0 0 373450 8.0500 NaN S

    字段注释

    • PassengerId => 乘客ID
    • Pclass => 乘客等级(1/2/3等舱位)
    • Name => 乘客姓名
    • Sex => 性别
    • Age => 年龄
    • SibSp => 堂兄弟/妹个数
    • Parch => 父母与小孩个数
    • Ticket => 船票信息
    • Fare => 票价
    • Cabin => 客舱
    • Embarked => 登船港口
    # 查看数据
    data_original.info()
    
    <class 'pandas.core.frame.DataFrame'>
    Int64Index: 1309 entries, 0 to 417
    Data columns (total 12 columns):
    PassengerId    1309 non-null int64
    Survived       1309 non-null int64
    Pclass         1309 non-null int64
    Name           1309 non-null object
    Sex            1309 non-null object
    Age            1046 non-null float64
    SibSp          1309 non-null int64
    Parch          1309 non-null int64
    Ticket         1309 non-null object
    Fare           1308 non-null float64
    Cabin          295 non-null object
    Embarked       1307 non-null object
    dtypes: float64(2), int64(5), object(5)
    memory usage: 132.9+ KB
    
    features = list(data_original.columns[data_original.dtypes != 'object'])
    print (features)
    
    ['PassengerId', 'Survived', 'Pclass', 'Age', 'SibSp', 'Parch', 'Fare']
    
    # 查看数字类型特征分布
    data_original[features].describe()
    
    PassengerId Survived Pclass Age SibSp Parch Fare
    count 1309.000000 1309.000000 1309.000000 1046.000000 1309.000000 1309.000000 1308.000000
    mean 655.000000 0.377387 2.294882 29.881138 0.498854 0.385027 33.295479
    std 378.020061 0.484918 0.837836 14.413493 1.041658 0.865560 51.758668
    min 1.000000 0.000000 1.000000 0.170000 0.000000 0.000000 0.000000
    25% 328.000000 0.000000 2.000000 21.000000 0.000000 0.000000 7.895800
    50% 655.000000 0.000000 3.000000 28.000000 0.000000 0.000000 14.454200
    75% 982.000000 1.000000 3.000000 39.000000 1.000000 0.000000 31.275000
    max 1309.000000 1.000000 3.000000 80.000000 8.000000 9.000000 512.329200
    # 查看类别特征值分布
    print (data_original['Sex'].value_counts())
    print (data_original['Embarked'].value_counts())
    
    male      843
    female    466
    Name: Sex, dtype: int64
    S    914
    C    270
    Q    123
    Name: Embarked, dtype: int64
    

    对类型特征进行转换

    # 类别特征独热编码
    data_onehot = pd.get_dummies(data_original,columns=['Sex','Embarked'])
    # data_onehot = data_original.copy()
    # data_original['Sex'].replace('male',0,inplace=True)   #inplace=True 替换
    data_onehot.head()
    
    PassengerId Survived Pclass Name Age SibSp Parch Ticket Fare Cabin Sex_female Sex_male Embarked_C Embarked_Q Embarked_S
    0 1 0 3 Braund, Mr. Owen Harris 22.0 1 0 A/5 21171 7.2500 NaN 0 1 0 0 1
    1 2 1 1 Cumings, Mrs. John Bradley (Florence Briggs Th... 38.0 1 0 PC 17599 71.2833 C85 1 0 1 0 0
    2 3 1 3 Heikkinen, Miss. Laina 26.0 0 0 STON/O2. 3101282 7.9250 NaN 1 0 0 0 1
    3 4 1 1 Futrelle, Mrs. Jacques Heath (Lily May Peel) 35.0 1 0 113803 53.1000 C123 1 0 0 0 1
    4 5 0 3 Allen, Mr. William Henry 35.0 0 0 373450 8.0500 NaN 0 1 0 0 1
    # 剔除非训练特征
    drop_features = ['PassengerId', 'Survived', 'Name','Ticket','Cabin']
    features_filted = list(data_onehot.columns.values)
    for feature in drop_features:
        features_filted.remove(feature)
    # features_filted = list(set(features_filted) - set(drop_features))
    print (features_filted)
    
    # 划分训练集和验证集
    x_train, x_test, y_train, y_test = train_test_split(data_onehot[features_filted], data_onehot['Survived'], random_state=1, train_size=0.7)
    display(x_train.shape)
    display(x_test.shape)
    display(y_train.shape)
    display(y_train.shape)
    
    ['Pclass', 'Age', 'SibSp', 'Parch', 'Fare', 'Sex_female', 'Sex_male', 'Embarked_C', 'Embarked_Q', 'Embarked_S']
    
    (916, 10)
    (393, 10)
    (916,)
    (916,)
    

    模型训练

    model.fit(x_train, y_train,eval_set=[(x_train,y_train),(x_test,y_test)],
           eval_metric=['logloss','auc'],early_stopping_rounds=10,verbose=True)
    
    [1]	training's binary_logloss: 0.595048	training's auc: 0.942605	valid_1's binary_logloss: 0.633623	valid_1's auc: 0.851209
    Training until validation scores don't improve for 10 rounds
    [2]	training's binary_logloss: 0.548373	training's auc: 0.945537	valid_1's binary_logloss: 0.592688	valid_1's auc: 0.851515
    [3]	training's binary_logloss: 0.510333	training's auc: 0.945868	valid_1's binary_logloss: 0.560726	valid_1's auc: 0.849079
    [4]	training's binary_logloss: 0.478709	training's auc: 0.948622	valid_1's binary_logloss: 0.534067	valid_1's auc: 0.853446
    [5]	training's binary_logloss: 0.451073	training's auc: 0.950018	valid_1's binary_logloss: 0.51243	valid_1's auc: 0.854005
    [6]	training's binary_logloss: 0.427676	training's auc: 0.951412	valid_1's binary_logloss: 0.49401	valid_1's auc: 0.858917
    [7]	training's binary_logloss: 0.407227	training's auc: 0.952531	valid_1's binary_logloss: 0.479078	valid_1's auc: 0.86363
    [8]	training's binary_logloss: 0.389879	training's auc: 0.953206	valid_1's binary_logloss: 0.466908	valid_1's auc: 0.864682
    [9]	training's binary_logloss: 0.374723	training's auc: 0.953082	valid_1's binary_logloss: 0.456975	valid_1's auc: 0.865215
    [10]	training's binary_logloss: 0.361178	training's auc: 0.954225	valid_1's binary_logloss: 0.446911	valid_1's auc: 0.869328
    [11]	training's binary_logloss: 0.349364	training's auc: 0.954401	valid_1's binary_logloss: 0.44059	valid_1's auc: 0.868982
    [12]	training's binary_logloss: 0.338051	training's auc: 0.955169	valid_1's binary_logloss: 0.435057	valid_1's auc: 0.869275
    [13]	training's binary_logloss: 0.328267	training's auc: 0.956474	valid_1's binary_logloss: 0.429733	valid_1's auc: 0.870247
    [14]	training's binary_logloss: 0.318925	training's auc: 0.957555	valid_1's binary_logloss: 0.427283	valid_1's auc: 0.870314
    [15]	training's binary_logloss: 0.311077	training's auc: 0.958657	valid_1's binary_logloss: 0.42482	valid_1's auc: 0.869488
    [16]	training's binary_logloss: 0.304002	training's auc: 0.959259	valid_1's binary_logloss: 0.423752	valid_1's auc: 0.867877
    [17]	training's binary_logloss: 0.296665	training's auc: 0.960373	valid_1's binary_logloss: 0.420685	valid_1's auc: 0.870247
    [18]	training's binary_logloss: 0.291046	training's auc: 0.960769	valid_1's binary_logloss: 0.421158	valid_1's auc: 0.86833
    [19]	training's binary_logloss: 0.285206	training's auc: 0.961702	valid_1's binary_logloss: 0.421062	valid_1's auc: 0.867185
    [20]	training's binary_logloss: 0.279439	training's auc: 0.962313	valid_1's binary_logloss: 0.421684	valid_1's auc: 0.866812
    [21]	training's binary_logloss: 0.274464	training's auc: 0.962969	valid_1's binary_logloss: 0.423581	valid_1's auc: 0.86576
    [22]	training's binary_logloss: 0.269943	training's auc: 0.963476	valid_1's binary_logloss: 0.423831	valid_1's auc: 0.866479
    [23]	training's binary_logloss: 0.264949	training's auc: 0.964407	valid_1's binary_logloss: 0.423879	valid_1's auc: 0.867238
    [24]	training's binary_logloss: 0.260584	training's auc: 0.965294	valid_1's binary_logloss: 0.425674	valid_1's auc: 0.866519
    Early stopping, best iteration is:
    [14]	training's binary_logloss: 0.318925	training's auc: 0.957555	valid_1's binary_logloss: 0.427283	valid_1's auc: 0.870314
    
    
    
    
    
    LGBMClassifier(n_estimators=200, n_jobs=1)
    

    参数说明

    • early_stopping_rounds:在连续加入10棵树之后,每一次模型的损失函数都没有下降,这时候停止加树,有监控作用

    • eval_set:进行测试的数据集

    • verbose=False不打印训练过程

    • objective 目标函数

    \quad回归任务

    \qquad reg:linear (默认)

    \qquad reg:logistic

    \quad二分类

    \qquad binary:logistic 概率

    \qquad binary:logitraw 类别

    \quad多分类

    \qquad multi:softmax num_class=n 返回类别

    \qquad multi:softprob num_class=n 返回概率

    \qquad rank:pairwise

    • eval_metric

    \quad回归任务(默认rmse)

    \qquad rmse–均方根误差

    \qquad mae–平均绝对误差

    \quad 分类任务(默认error)

    \qquad auc–roc曲线下面积

    \qquad error–错误率(二分类)

    \qquad merror–错误率(多分类)

    \qquad logloss–负对数似然函数(二分类)

    \qquad mlogloss–负对数似然函数(多分类)

    特征重要性

    importance_df = pd.DataFrame({
        'features':x_train.columns.values,
        'importance':model.feature_importances_.tolist()
    })
    importance_df = importance_df.sort_values('importance',ascending=False)
    importance_df
    
    features importance
    1 Age 171
    4 Fare 151
    0 Pclass 26
    2 SibSp 18
    7 Embarked_C 16
    5 Sex_female 14
    3 Parch 11
    9 Embarked_S 6
    8 Embarked_Q 5
    6 Sex_male 0
    import seaborn as sns
    import matplotlib.pyplot as plt
    plt.figure(figsize=(10,6))
    sns.barplot(importance_df['importance'][:20],importance_df['features'][:20])
    plt.show()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eulNUELN-1616579576196)(output_19_0.png)]

    混淆矩阵

    pred_y_test = model.predict(x_test)
    # m = metrics.confusion_matrix(y_test, pred_y_test)
    # display (m)
    tn, fp, fn, tp = metrics.confusion_matrix(y_test, pred_y_test).ravel()
    print ('matrix    label1   label0')
    print ('predict1  {:<6d}   {:<6d}'.format(int(tp), int(fp)))
    print ('predict0  {:<6d}   {:<6d}'.format(int(fn), int(tn)))
    
    matrix    label1   label0
    predict1  116      15    
    predict0  48       214   
    

    交叉验证

    验证模型得分

    score_x = x_train
    score_y = y_train
    
    # 正确率
    scores = cross_val_score(model, score_x, score_y, cv=5, scoring='accuracy')
    print('交叉验证正确率为:'+str(scores.mean()))  
    
    交叉验证正确率为:0.8394986932763127
    
    # 精确率
    scores = cross_val_score(model, score_x, score_y, cv=5, scoring='precision')
    print('交叉验证精确率为:'+str(scores.mean()))  
    
    交叉验证精确率为:0.8043572452360251
    
    # 召回率
    scores = cross_val_score(model, score_x, score_y, cv=5, scoring='recall')
    print('交叉验证召回率为:'+str(scores.mean()))  
    
    交叉验证召回率为:0.7424242424242424
    
    # f1_score
    scores = cross_val_score(model, score_x, score_y, cv=5, scoring='f1')
    print('交叉验证f1_score为:'+str(scores.mean()))  
    
    交叉验证f1_score为:0.7695365479961331
    

    TopN

    当样本不均衡且比较关注召回率时使用TopN来评估模型,泰坦尼克号乘客生存率预测不适合用TopN来评判模型预测好还。

    ratio_list = [0.01,0.02,0.05,0.1,0.2]
    test_label = pd.DataFrame(y_test)
    index_of_label1 = model.classes_.tolist().index(1)
    pred_y_test = model.predict(x_test)
    proba_y_test = model.predict_proba(x_test)
    test_label['predict'] = pred_y_test
    test_label['label_1'] = proba_y_test[:,index_of_label1]
    display (test_label.head())
    
    label_1_nbr = len(test_label[test_label['Survived']==1])
    print ('label_1_nbr:',label_1_nbr)
    print ('sample number:',len(test_label))
    
    for ratio in ratio_list:
        num = test_label.sort_values('label_1',ascending=False)[:int(ratio*test_label.shape[0])]['Survived'].sum()
        count = test_label.sort_values('label_1',ascending=False)[:int(ratio*test_label.shape[0])]['Survived'].count()
        print ('Top %.2f label_1_nbr:%d,sample_nbr:%d,recall:%f'%(ratio,num,count,1.0*num/label_1_nbr))
    
    Survived predict label_1
    201 0 0 0.111261
    115 0 0 0.163787
    255 1 0 0.451979
    212 0 0 0.192941
    195 1 1 0.852887
    label_1_nbr: 164
    sample number: 393
    Top 0.01 label_1_nbr:3,sample_nbr:3,recall:0.018293
    Top 0.02 label_1_nbr:7,sample_nbr:7,recall:0.042683
    Top 0.05 label_1_nbr:19,sample_nbr:19,recall:0.115854
    Top 0.10 label_1_nbr:38,sample_nbr:39,recall:0.231707
    Top 0.20 label_1_nbr:73,sample_nbr:78,recall:0.445122
    

    网格搜索最佳参数

    param_grid = [
    {'n_estimators': [3, 10, 30],'learning_rate': [0.01,0.05,0.1]}
    ]
    
    clf = lgb.LGBMClassifier()
    grid_search = GridSearchCV(clf, param_grid, cv=5,scoring='neg_mean_squared_error')
    grid_search.fit(x_train, y_train)
    print (grid_search.best_params_)
    print (grid_search.best_estimator_)
    
    {'learning_rate': 0.1, 'n_estimators': 30}
    LGBMClassifier(n_estimators=30)
    

    Mnist 手写数字识别

    # 加载数据
    traindata_path = u'D:/01_Project/99_test/ML/mnist/mnist_train.csv'
    testdata_path = u'D:/01_Project/99_test/ML/mnist/mnist_test.csv'
    # testresult_path = u'D:/01_Project/99_test/ML/titanic/gender_submission.csv'
    df_train = pd.read_csv(traindata_path)
    x_train = df_train.iloc[:,1:]
    y_train = df_train.iloc[:,0]
    print (x_train.shape)
    display (y_train[:5])
    display (x_train.head(5))
    
    df_test = pd.read_csv(testdata_path)
    x_test = df_test.iloc[:,1:]
    y_test = df_test.iloc[:,0]
    print (x_test.shape)
    display (y_test[:5])
    display (x_test.head(5))
    
    (59999, 784)
    
    0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.20 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.30 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.40 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.50 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.60 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.70 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.80 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.90 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 ... 0.518 0.519 0.520 0.521 0.522 0.523 0.524 0.525 0.526 0.527 0.528 0.529 0.530 0.531 0.532 0.533 0.534 0.535 0.536 0.537 0.538 0.539 0.540 0.541 0.542 0.543 0.544 0.545 0.546 0.547 0.548 0.549 0.550 0.551 0.552 0.553 0.554 0.555 0.556 0.557 0.558 0.559 0.560 0.561 0.562 0.563 0.564 0.565 0.566 0.567 0.568 0.569 0.570 0.571 0.572 0.573 0.574 0.575 0.576 0.577 0.578 0.579 0.580 0.581 0.582 0.583 0.584 0.585 0.586 0.587 0.588 0.589 0.590 0.591 0.592 0.593 0.594 0.595 0.596 0.597 0.598 0.599 0.600 0.601 0.602 0.603 0.604 0.605 0.606 0.607 0.608 0.609 0.610 0.611 0.612 0.613 0.614 0.615 0.616 0.617
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 96 254 153 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 96 252 189 42 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 184 252 170 11 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 147 252 42 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

    5 rows × 784 columns

    (9999, 784)
    
    0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.20 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.30 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.40 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.50 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.60 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.70 0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.80 0.81 0.82 0.83 0.84 0.85 0.86 0.87 0.88 0.89 0.90 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 ... 254.22 254.23 52.2 0.580 0.581 0.582 0.583 0.584 0.585 0.586 0.587 0.588 0.589 0.590 0.591 0.592 0.593 0.594 0.595 0.596 0.597 0.598 0.599 0.600 0.601 0.602 121 254.24 254.25 219.1 40 0.603 0.604 0.605 0.606 0.607 0.608 0.609 0.610 0.611 0.612 0.613 0.614 0.615 0.616 0.617 0.618 0.619 0.620 0.621 0.622 0.623 0.624 0.625 121.1 254.26 207 18.1 0.626 0.627 0.628 0.629 0.630 0.631 0.632 0.633 0.634 0.635 0.636 0.637 0.638 0.639 0.640 0.641 0.642 0.643 0.644 0.645 0.646 0.647 0.648 0.649 0.650 0.651 0.652 0.653 0.654 0.655 0.656 0.657 0.658 0.659 0.660 0.661 0.662 0.663 0.664 0.665 0.666 0.667
    0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 116 125 171 255 255 150 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 0 0 0 0 179 66 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
    4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ... 157 107 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

    5 rows × 784 columns

    # 展示图片
    img = np.array(x_train.iloc[0,:]).reshape(28, 28)
    plt.imshow(img, cmap='Greys', interpolation='nearest')
    plt.show();
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-scHuY8ZF-1616579576202)(output_34_0.png)]

    # 模型参数设定
    model = lgb.LGBMClassifier(boosting_type='gbdt'
                              ,class_weight=None
                              ,colsample_bytree=1.0
                              ,importance_type='split'
                              ,learning_rate=0.1
                              ,max_depth=-1
                              ,min_child_samples=20
                              ,min_child_weight=0.001
                              ,min_split_gain=0.0
                              ,n_estimators=100
                              ,n_jobs=1
                              ,num_leaves=31
                              ,objective='multi:softmax'
                              ,random_state=None
                              ,reg_alpha=0.0
                              ,reg_lambda=0.0
                              ,silent=True
                              ,subsample=1.0
                              ,subsample_for_bin=200000)
    
    model.fit(x_train, y_train,eval_set=[(x_train,y_train),(x_test,y_test)],
           eval_metric=['logloss'],early_stopping_rounds=20,verbose=True)
    
    [1]	training's multi_logloss: 1.67939	valid_1's multi_logloss: 1.68286
    Training until validation scores don't improve for 20 rounds
    [2]	training's multi_logloss: 1.37326	valid_1's multi_logloss: 1.38176
    [3]	training's multi_logloss: 1.15968	valid_1's multi_logloss: 1.17275
    [4]	training's multi_logloss: 0.997105	valid_1's multi_logloss: 1.01395
    [5]	training's multi_logloss: 0.867815	valid_1's multi_logloss: 0.88653
    

    .
    .
    .
    [196] training’s multi_logloss: 0.000162272 valid_1’s multi_logloss: 0.0638985
    [197] training’s multi_logloss: 0.000156578 valid_1’s multi_logloss: 0.0639573
    [198] training’s multi_logloss: 0.000151258 valid_1’s multi_logloss: 0.0640798
    [199] training’s multi_logloss: 0.000145979 valid_1’s multi_logloss: 0.0640982
    Early stopping, best iteration is:
    [179] training’s multi_logloss: 0.000294704 valid_1’s multi_logloss: 0.0635952

    LGBMClassifier(n_estimators=200, n_jobs=1, objective='multi:softmax')
    
    pred_y_test = model.predict(x_test)
    m = metrics.confusion_matrix(y_test, pred_y_test)
    display (m)
    
    
    array([[ 969,    0,    0,    0,    0,    2,    3,    1,    5,    0],
           [   0, 1125,    2,    3,    0,    1,    1,    1,    2,    0],
           [   3,    0, 1012,    5,    1,    0,    1,    6,    4,    0],
           [   0,    0,    3,  992,    0,    3,    0,    8,    4,    0],
           [   0,    0,    5,    0,  962,    0,    3,    0,    2,   10],
           [   2,    0,    1,    8,    0,  869,    7,    2,    2,    1],
           [   5,    2,    0,    0,    2,    7,  938,    0,    4,    0],
           [   1,    0,   12,    3,    2,    0,    0, 1003,    1,    5],
           [   4,    0,    2,    0,    3,    0,    0,    2,  958,    5],
           [   4,    4,    1,    7,    6,    1,    0,    4,    1,  981]],
          dtype=int64)
    

    多分类评估

    • precision_score
    • accuracy_score
    • recall_score
    • f1_score

    \quad二分类时average参数默认是binary,多分类时,可选参数有micro、macro、weighted和samples

    \quadmicro算法是指把所有的类放在一起算,具体到precision,就是把所有类的TP加和,再除以所有类的TP和FN的加和。因此micro方法下的precision和recall都等于accuracy

    \quadmacro方法就是先分别求出每个类的precision再算术平均

    \quad前面提到的macro算法是取算术平均,weighted算法就是在macro算法的改良版,不再是取算术平均、乘以固定weight(也就是1/3)了,而是乘以该类在总样本数中的占比

    print ('precision_score:',metrics.precision_score(y_test,pred_y_test,labels=None,pos_label=1,average='weighted',sample_weight=None))
    print ('accuracy_score:',metrics.accuracy_score(y_test,pred_y_test))
    print ('recall_score:',metrics.recall_score(y_test,pred_y_test,labels=None,pos_label=1,average='weighted',sample_weight=None))
    print ('f1_score:',metrics.f1_score(y_test,pred_y_test,labels=None,pos_label=1,average='weighted',sample_weight=None))
    
    precision_score: 0.9810242986297515
    accuracy_score: 0.980998099809981
    recall_score: 0.980998099809981
    f1_score: 0.9809998617011098
    

    参考链接:

    展开全文
  • 文章目录一、LightGBM 原生接口重要参数训练参数预测方法绘制特征重要性分类例子回归例子二、LightGBM 的 sklearn 风格接口LGBMClassifier基本使用例子LGBMRegressor基本使用例子三、LightGBM 调参思路四、参数网格...

    与 xgboost 类似,LightGBM包含原生接口和 sklearn 风格接口两种,并且二者都实现了分类和回归的功能。如果想了解一些理论性的内容,可以看看之前的文章:LightGBM 相关知识理解

    一、LightGBM 原生接口

    重要参数

    boosting / boost / boosting_type

    用于指定弱学习器的类型,默认值为 ‘gbdt’,表示使用基于树的模型进行计算。还可以选择为 ‘gblinear’ 表示使用线性模型作为弱学习器。

    可选的参数值有:

    • ‘gbdt’,使用梯度提升树
    • ‘rf’,使用随机森林
    • ‘dart’,不太了解,官方解释为 Dropouts meet Multiple Additive Regression Trees
    • ‘goss’,使用单边梯度抽样算法,速度很快,但是可能欠拟合。

    推荐设置为 'gbdt’

    objective / application

    用于指定学习任务及相应的学习目标,常用的可选参数值如下:

    • “regression”,使用L2正则项的回归模型(默认值)。
    • “regression_l1”,使用L1正则项的回归模型。
    • “mape”,平均绝对百分比误差。
    • “binary”,二分类。
    • “multiclass”,多分类。

    num_class

    用于设置多分类问题的类别个数。

    min_child_samples

    叶节点样本的最少数量,默认值20,用于防止过拟合。

    learning_rate / eta

    LightGBM 不完全信任每个弱学习器学到的残差值,为此需要给每个弱学习器拟合的残差值都乘上取值范围在(0, 1] 的 eta,设置较小的 eta 就可以多学习几个弱学习器来弥补不足的残差。

    推荐的候选值为:[0.01, 0.015, 0.025, 0.05, 0.1]

    max_depth

    指定树的最大深度,默认值为-1,表示不做限制,合理的设置可以防止过拟合。

    推荐的数值为:[3, 5, 6, 7, 9, 12, 15, 17, 25]

    num_leaves

    指定叶子的个数,默认值为31,此参数的数值应该小于 2max_depth2^{max\_depth}

    feature_fraction / colsample_bytree

    构建弱学习器时,对特征随机采样的比例,默认值为1。

    推荐的候选值为:[0.6, 0.7, 0.8, 0.9, 1]

    bagging_fraction / subsample

    默认值1,指定采样出 subsample * n_samples 个样本用于训练弱学习器。注意这里的子采样和随机森林不一样,随机森林使用的是放回抽样,而这里是不放回抽样。 取值在(0, 1)之间,设置为1表示使用所有数据训练弱学习器。如果取值小于1,则只有一部分样本会去做GBDT的决策树拟合。选择小于1的比例可以减少方差,即防止过拟合,但是会增加样本拟合的偏差,因此取值不能太低。

    注意: bagging_freq 设置为非0值时才生效。

    推荐的候选值为:[0.6, 0.7, 0.8, 0.9, 1]

    bagging_freq / subsample_freq

    数值型,默认值0,表示禁用样本采样。如果设置为整数 z ,则每迭代 k 次执行一次采样。

    lambda_l1

    L1正则化权重项,增加此值将使模型更加保守。

    推荐的候选值为:[0, 0.01~0.1, 1]

    lambda_l2

    L2正则化权重项,增加此值将使模型更加保守。

    推荐的候选值为:[0, 0.1, 0.5, 1]

    min_gain_to_split / min_split_gain

    指定叶节点进行分支所需的损失减少的最小值,默认值为0。设置的值越大,模型就越保守。

    **推荐的候选值为:[0, 0.05 ~ 0.1, 0.3, 0.5, 0.7, 0.9, 1] **

    min_sum_hessian_in_leaf / min_child_weight

    指定孩子节点中最小的样本权重和,如果一个叶子节点的样本权重和小于min_child_weight则拆分过程结束,默认值为1。

    推荐的候选值为:[1, 3, 5, 7]

    metric

    用于指定评估指标,可以传递各种评估方法组成的list。常用的评估指标如下:

    • ‘mae’,用于回归任务,效果与 ‘mean_absolute_error’, ‘l1’ 相同。
    • ‘mse’,用于回归任务,效果与 ‘mean_squared_error’, ‘l2’ 相同。
    • ‘rmse’,用于回归任务,效果与 ‘root_mean_squared_error’, ‘l2_root’ 相同。
    • ‘auc’,用于二分类任务。
    • ‘binary’,用于二分类任务。
    • ‘binary_logloss’,用于二分类任务。
    • ‘binary_error’,用于二分类任务。
    • ‘multiclass’,用于多分类。
    • ‘multi_logloss’, 用于多分类。
    • ‘multi_error’, 用于多分类。

    seed / random_state

    指定随机数种子。

    训练参数

    以lightgbm.train为主,参数及默认值如下:

    lightgbm.train(params, train_set, num_boost_round=100, valid_sets=None, valid_names=None, fobj=None, feval=None, init_model=None, feature_name='auto', categorical_feature='auto', early_stopping_rounds=None, evals_result=None, verbose_eval=True, learning_rates=None, keep_training_booster=False, callbacks=None)
    

    1,params

    字典类型,用于指定各种参数,例如:{‘booster’:‘gbtree’,‘eta’:0.1}

    2,train_set

    用于训练的数据,通过给下面的方法传递数据和标签来构造:

    train_data = lgb.Dataset(train_x, train_y)
    

    3,num_boost_round

    指定最大迭代次数,默认值为10

    4,valid_sets

    列表类型,用于指定训练过程中用于评估的数据及数据的名称。例如:[train_data, valid_data]

    train_data = lgb.Dataset(train_x, train_y)
    valid_data = lgb.Dataset(valid_x, valid_y, reference=train)
    

    5,fobj

    可以指定二阶可导的自定义目标函数。

    6,feval

    自定义评估函数。

    7,categorical_feature

    指定哪些是类别特征。

    8,early_stopping_rounds

    指定迭代多少次没有得到优化则停止训练,默认值为None,表示不提前停止训练。

    注意:valid_sets 必须非空才能生效,如果有多个数据集,则以最后一个数据集为准。

    9,verbose_eval

    可以是bool类型,也可以是整数类型。如果设置为整数,则每间隔verbose_eval次迭代就输出一次信息。

    10,init_model

    加载之前训练好的 lgb 模型,用于增量训练。

    预测方法

    predict(data, num_iteration=None)
    

    参数说明:

    • data:string, numpy array, pandas DataFrame
    • num_iteration:选择第几次迭代用于预测,如果使用了 early_stopping_rounds,那么最佳的一次迭代将被使用

    注意,对于分类问题,predict 方法返回的是属于各个类别的概率,需要执行下面的语句才能获取到预测的类别:

    y_pred = model.predict(X_test)
    y_pred = np.argmax(y_pred, axis=1)
    

    绘制特征重要性

    代码如下:

    from lightgbm import plot_importance
    # 显示重要特征,max_num_features 指定显示多少个特征
    plot_importance(lgb_model, max_num_features)
    plt.show()
    

    分类例子

    from sklearn.datasets import load_iris
    import lightgbm as lgb
    from lightgbm import plot_importance
    import matplotlib.pyplot  as plt
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 加载鸢尾花数据集
    iris = load_iris()
    X,y = iris.data,iris.target
    # 数据集分割
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=123457)
    
    # 参数
    params = {
        'booster': 'gbtree',
        'objective': 'multiclass',
        'num_class': 3,
        'num_leaves': 31,
        'subsample': 0.8,
        'bagging_freq': 1,
        'feature_fraction ': 0.8,
        'slient': 1,
        'learning_rate ': 0.01,
        'seed': 0
    }
    
    # 构造训练集
    dtrain = lgb.Dataset(X_train,y_train)
    dtest = lgb.Dataset(X_test,y_test)
    num_rounds = 500
    # xgboost模型训练
    model = lgb.train(params,dtrain, num_rounds, valid_sets=[dtrain, dtest], 
                      verbose_eval=100, early_stopping_rounds=100)
    
    # 对测试集进行预测
    y_pred = model.predict(X_test)
    # 计算准确率
    accuracy = accuracy_score(y_test, np.argmax(y_pred, axis=1))
    print('accuarcy:%.2f%%'%(accuracy*100))
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    

    输出结果:

    Training until validation scores don't improve for 100 rounds.
    [100]	training's multi_logloss: 0.0200407	valid_1's multi_logloss: 0.16259
    Early stopping, best iteration is:
    [58]	training's multi_logloss: 0.0522685	valid_1's multi_logloss: 0.113599
    accuarcy:96.67%
    

    在这里插入图片描述

    回归例子

    from sklearn.datasets import load_boston
    import lightgbm as lgb
    from lightgbm import plot_importance
    import matplotlib.pyplot  as plt
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import mean_squared_error
    
    # 加载波士顿房价预测数据集
    boston = load_boston()
    X,y = boston.data,boston.target
    
    # 数据集分割
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=0)
    
    params = {
        'booster': 'gbtree',
        'objective': 'regression',
        'num_leaves': 31,
        'subsample': 0.8,
        'bagging_freq': 1,
        'feature_fraction ': 0.8,
        'slient': 1,
        'learning_rate ': 0.01,
        'seed': 0
    }
    
    
    # 构造训练集
    dtrain = lgb.Dataset(X_train,y_train)
    dtest = lgb.Dataset(X_test,y_test)
    num_rounds = 500
    # xgboost模型训练
    model = lgb.train(params,dtrain, num_rounds, valid_sets=[dtrain, dtest], 
                      verbose_eval=100, early_stopping_rounds=100)
    
    # 对测试集进行预测
    y_pred = model.predict(X_test)
    print('mse:', mean_squared_error(y_test, y_pred))
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    

    输出:

    Training until validation scores don't improve for 100 rounds.
    [100]	training's l2: 1.98858	valid_1's l2: 22.4685
    [200]	training's l2: 0.76671	valid_1's l2: 21.9116
    Early stopping, best iteration is:
    [141]	training's l2: 1.29078	valid_1's l2: 21.7546
    mse: 21.754638427136342
    

    在这里插入图片描述

    二、LightGBM 的 sklearn 风格接口

    LGBMClassifier

    基本使用

    LGBMClassifier的引入以及重要参数的默认值如下:

    from lightgbm import LGBMClassifier
    # 重要参数:
    lgb_model = LGBMClassifier(
        boosting_type='gbdt',
        num_leaves=31,
        max_depth=-1,
        learning_rate=0.1,
        n_estimators=100,
        objective='binary', # 默认是二分类
        min_split_gain=0.0,
        min_child_samples=20,
        subsample=1.0,
        subsample_freq=0,
        colsample_bytree=1.0,
        reg_alpha=0.0,
        reg_lambda=0.0,
        random_state=None,
        silent=True
    )
    

    其中绝大多数的参数在上文已经说明,不再赘述。

    与原生的LightGBM相比,LGBMClassifier并不是调用train方法进行训练,而是使用fit方法:

    lgb_model.fit(
        X, # array, DataFrame 类型
        y, # array, Series 类型
        eval_set=None, # 用于评估的数据集,例如:[(X_train, y_train), (X_test, y_test)]
        eval_metric=None, # 评估函数,字符串类型,例如:'l2', 'logloss'
        early_stopping_rounds=None, 
        verbose=True # 设置为正整数表示间隔多少次迭代输出一次信息
    )
    

    预测的方法有两种:

    lgb_model.predict(data) # 返回预测值
    lgb_model.predict_proba(data) # 返回各个样本属于各个类别的概率
    

    例子

    from lightgbm import LGBMClassifier
    from sklearn.datasets import load_iris
    from lightgbm import plot_importance
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 加载样本数据集
    iris = load_iris()
    X,y = iris.data,iris.target
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=12343)
    
    model = LGBMClassifier(
        max_depth=3,
        learning_rate=0.1,
        n_estimators=200, # 使用多少个弱分类器
        objective='multiclass',
        num_class=3,
        booster='gbtree',
        min_child_weight=2,
        subsample=0.8,
        colsample_bytree=0.8,
        reg_alpha=0,
        reg_lambda=1,
        seed=0 # 随机数种子
    )
    model.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)], 
              verbose=100, early_stopping_rounds=50)
    
    # 对测试集进行预测
    y_pred = model.predict(X_test)
    model.predict_proba
    #计算准确率
    accuracy = accuracy_score(y_test,y_pred)
    print('accuracy:%3.f%%'%(accuracy*100))
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    

    输出:

    Training until validation scores don't improve for 50 rounds.
    Early stopping, best iteration is:
    [42]	training's multi_logloss: 0.0831629	valid_1's multi_logloss: 0.183711
    accuracy: 97%
    

    在这里插入图片描述

    LGBMRegressor

    基本使用

    XGBRegressor与XGBClassifier类似,其引入以及重要参数的默认值如下:

    from lightgbm import LGBMRegressor
    # 重要参数:
    lgb_model = LGBMRegressor(
        boosting_type='gbdt',
        num_leaves=31,
        max_depth=-1,
        learning_rate=0.1,
        n_estimators=100,
        objective='regression', # 默认是二分类
        min_split_gain=0.0,
        min_child_samples=20,
        subsample=1.0,
        subsample_freq=0,
        colsample_bytree=1.0,
        reg_alpha=0.0,
        reg_lambda=0.0,
        random_state=None,
        silent=True
    )
    

    其 fit 方法、predict方法与 LGBMClassifier几乎相同,不再重复说明。

    例子

    from lightgbm import LGBMRegressor
    from lightgbm import plot_importance
    import matplotlib.pyplot as plt
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_boston
    from sklearn.metrics import mean_squared_error
    
    # 导入数据集
    boston = load_boston()
    X ,y = boston.data,boston.target
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=0)
    
    model = LGBMRegressor(
        boosting_type='gbdt',
        num_leaves=31,
        max_depth=-1,
        learning_rate=0.1,
        n_estimators=100,
        objective='regression', # 默认是二分类
        min_split_gain=0.0,
        min_child_samples=20,
        subsample=1.0,
        subsample_freq=0,
        colsample_bytree=1.0,
        reg_alpha=0.0,
        reg_lambda=0.0,
        random_state=None,
        silent=True
    )
    
    model.fit(X_train,y_train, eval_set=[(X_train, y_train), (X_test, y_test)], 
              verbose=100, early_stopping_rounds=50)
    
    # 对测试集进行预测
    y_pred = model.predict(X_test)
    mse = mean_squared_error(y_test,y_pred)
    print('mse', mse)
    
    # 显示重要特征
    plot_importance(model)
    plt.show()
    

    输出:

    Training until validation scores don't improve for 50 rounds.
    [100]	training's l2: 1.99687	valid_1's l2: 24.4987
    Did not meet early stopping. Best iteration is:
    [100]	training's l2: 1.99687	valid_1's l2: 24.4987
    mse 24.498696726728348
    

    在这里插入图片描述

    三、LightGBM 调参思路

    (1)选择较高的学习率,例如0.1,这样可以减少迭代用时。

    (2)然后对 max_depth, num_leaves, min_data_in_leaf, min_split_gain, subsample, colsample_bytree 这些参数进行调整。

    其中,num_leaves < 2max_depth2^{max\_depth}。而 min_data_in_leaf 是一个很重要的参数, 也叫min_child_samples,它的值取决于训练数据的样本个树和num_leaves. 将其设置的较大可以避免生成一个过深的树, 但有可能导致欠拟合。

    其他参数的合适候选值为:

    • max_depth:[3, 5, 6, 7, 9, 12, 15, 17, 25]
    • min_split_gain:[0, 0.05 ~ 0.1, 0.3, 0.5, 0.7, 0.9, 1]
    • subsample:[0.6, 0.7, 0.8, 0.9, 1]
    • colsample_bytree:[0.6, 0.7, 0.8, 0.9, 1]

    (3)调整正则化参数 reg_lambda , reg_alpha,这些参数的合适候选值为:

    • reg_alpha:[0, 0.01~0.1, 1]
    • reg_lambda :[0, 0.1, 0.5, 1]

    (4)降低学习率,继续调整参数,学习率合适候选值为:[0.01, 0.015, 0.025, 0.05, 0.1]

    四、参数网格搜索

    from sklearn.datasets import load_iris
    import lightgbm as lgb
    from sklearn.model_selection import GridSearchCV  # Perforing grid search
    from sklearn.model_selection import train_test_split
    
    # 加载样本数据集
    iris = load_iris()
    X,y = iris.data,iris.target
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=12343)
    train_x, valid_x, train_y, valid_y = train_test_split(X, y, test_size=0.333, random_state=0)   # 分训练集和验证集
    train = lgb.Dataset(train_x, train_y)
    valid = lgb.Dataset(valid_x, valid_y, reference=train)
    
    
    parameters = {
                  'max_depth': [15, 20, 25, 30, 35],
                  'learning_rate': [0.01, 0.02, 0.05, 0.1, 0.15],
                  'feature_fraction': [0.6, 0.7, 0.8, 0.9, 0.95],
                  'bagging_fraction': [0.6, 0.7, 0.8, 0.9, 0.95],
                  'bagging_freq': [2, 4, 5, 6, 8],
                  'lambda_l1': [0, 0.1, 0.4, 0.5, 0.6],
                  'lambda_l2': [0, 10, 15, 35, 40],
                  'cat_smooth': [1, 10, 15, 20, 35]
    }
    gbm = LGBMClassifier(max_depth=3,
                        learning_rate=0.1,
                        n_estimators=200, # 使用多少个弱分类器
                        objective='multiclass',
                        num_class=3,
                        booster='gbtree',
                        min_child_weight=2,
                        subsample=0.8,
                        colsample_bytree=0.8,
                        reg_alpha=0,
                        reg_lambda=1,
                        seed=0 # 随机数种子
                    )
    # 有了gridsearch我们便不需要fit函数
    gsearch = GridSearchCV(gbm, param_grid=parameters, scoring='accuracy', cv=3)
    gsearch.fit(train_x, train_y)
    
    print("Best score: %0.3f" % gsearch.best_score_)
    print("Best parameters set:")
    best_parameters = gsearch.best_estimator_.get_params()
    for param_name in sorted(parameters.keys()):
        print("\t%s: %r" % (param_name, best_parameters[param_name]))
    

    参考文章:

    Parameters

    lightgbm.LGBMClassifier

    lightgbm.LGBMRegressor

    LightGBM核心解析与调参

    展开全文
  • xgboost的特征重要性函数:feature_importances_: feature_importances_四种参数选怎,gain为xgboost默认选项(注意:lightGBM模型为weight): ‘weight’: the number of times a feature is used
  • 资料参考: 1. Evaluate Feature Importance using Tree-based Model 2. lgbm.fi.plot: LightGBM Feature Importance Plotting ... 在本博客中,我将使用LightGBM中的GBDT模型来评估特性重要性的步骤。 ...
  • LightGBM使用总结

    2019-06-27 17:33:12
    绘制特征重要性条形图: plt.figure(figsize=(12,6)) lgb.plot_importance(model, max_num_features=30) plt.title("Featurertances") plt.show() tiaocan https://www.cnblogs.com/wzdLY/p/9867719.html ...
  • python实现LightGBM(进阶)

    2020-10-10 15:19:42
    特征重要性6. 模型预测7. 存储并读取模型(pickle)8. 训练(断点训练/学习率衰减/训练过程修改参数)9. 自定义目标函数/评价指标10. 回调函数 1. 模块准备 import json import lightgbm as lgb import pandas as ...
  • 最近在公司做项目,用xgboost、lightgbm分析特征重要性,做个baseline,正好写下对xgboost和lightgbm最新的理解 Chap01: 正好看到一道面试题: 我面试候选人时必问的一个问题 GBDT中的梯度是什么对什么的梯度?...
  • 随机森林 优点 具有极高的准确率 ... 实现简单,训练速度快,可以得到变量重要性排序(计算每个特征在分裂时被选到的次数或者某个特征不纯度平均下降了多少) 容易实现并行化 在创建随机森林的时候,对gen...
  • 结果2.1 准确率2.2 训练时间和预测时间2.3 可解释性2.3.1 特征重要性2.3.2 SHAP值2.3.3 可视化二叉树3. 总结4. 代码参考文献 1. 对比标准 1.1 数据集 分类:Fashion MNIST(60000条数据784个特征) 回归:NYC Taxi ...
  • 特征重要性评估 &nbsp;&nbsp;&nbsp;&nbsp;基于树的集成算法有一个很好的特性,就是模型训练结束后可以输出模型所使用的特征的相对重要性,便于理解哪些因素是对预测有关键影响,有效筛选特征。 ...
  • 该部分是代码整理的第二部分,为了方便一些初学者调试代码,作者已将该部分代码打包成一个工程文件,包含简单的数据处理、xgboost配置、五折交叉训练和模型特征重要性打印四个部分。数据处理部分参考:代码整理一,...
  • 打印模型特征重要性

    2020-12-29 14:09:36
    1. 获得特征重要性信息 def get_feature_importance_pair(gbm_model): feature_name_list = gbm_model.feature_name() importance_list = list(gbm_model.feature_importance()) feature_importance_pair = [...
  • adaboost模型分类贝叶斯调参adaboost模型分类F1 分数混淆矩阵adaboost获取特征重要性4.GBDT模型分类贝叶斯调参GBDT模型分类绘制混淆矩阵5. LightGBM分类(未调参)模型评估F1 分数绘制重要的特征6. XGBoost分类...
  • scale 针对df做scale 错误????‍♂️方式 ...特征重要性 调包 import matplotlib.pyplot as plt plt.figure(figsize=(12,6)) lgb.plot_importance(model, max_num_features=30) plt.title("LightGBM ...
  • 我们在构建树类模型(XGBoost、LightGBM等)时,如果想要知道哪些变量比较重要的话,可以通过模型的feature_importances_方法来获取特征重要性。例如LightGBM的feature_importances_可以通过特征的分裂次数或利用该...
  • 特征工程的建立过程

    2020-08-24 16:28:25
    特征工程重要性 特征越好,模型的性能越出色 特征越好,构建的模型越简单 特征越好,模型的灵活性越强 1.2 特征提取与特征组合 特征提取 基于数据分析与探索提取 箱型图分析 点线图分析 离散型特征很重要: 可用于...
  • 功能选择器:Python中的简单功能选择 特征选择器是用于减少机器学习数据集的维...lightgbm==2.1.1 matplotlib==2.1.2 seaborn==0.8.1 numpy==1.14.5 pandas==0.23.1 scikit-learn==0.19.1 接触 如有任何疑问,请联系 !
  • PermutationImportance

    2021-03-16 21:25:41
    方法来获取特征重要性。例如LightGBM的feature_importances_可以通过特征的分裂次数或利用该特征分裂后的增益来衡量。一般情况下,不同的衡量准则得到的特征重要性顺序会有差异。我一般是通过多种评价标准来交叉选择...
  • 可以通过模型的feature_importances_方法来获取特征重要性。例如LightGBM的feature_importances_可以通过特征的分裂次数或利用该特征分裂后的增益来衡量。一般情况下,不同的衡量准则得到的特征重要性顺序会有差异。...
  • 随机目标,训练模型,得到不管目标情况下的特征重要性,例如使用lightgbm可以包括split 和gain score,训练多次,可以得到多次特征重要性的分布 利用真实的目标,训练模型,得到真实的目标的重要程度,这样就可以与...
  • 然后报告每个特征重要性的均值和标准差(跨折)。 如果没有将模型作为参数传递给LOFO Importance,它将作为默认模型运行LightGBM。 安装 可以使用以下方法安装LOFO重要性 pip install lofo-importance LOFO重要性...
  • 一、特征工程 1.重要性 数据挖掘二八法则,80%选取特征,20%模型融合。特征越好,模型的性能越出色,构建的模型越简单,模型的灵活性越强...3)离线型特征重要性:可用于设计规则,易于模型拟合,xgboost,lightgbm,c
  • 时间序列 —— task04

    2020-08-24 23:17:28
    特征工程的重要性 特征越好,模型的性能越出色 特征越好,构建的模型越简单 特征越好,模型的灵活性越强 特征提取 基于数据分析与探索提取 箱型图分析 点线图分析 离散型特征很重要 可用于设计规则 易于...
  • 构建集成模型,比较有意思的是LightGBM可以得到特征重要性排序; 多模型集成。 值得注意的是最后虽然响应是离散值,但是进行模型集成的时候,将响应视作连续值进行回归貌似比分类效果好。 ...
  • 当前,ELI5允许解释scikit学习线性分类器和回归变量的权重和预测,将决策树打印为文本或SVG,显示特征重要性,并解释决策树和基于树的集合的预测。 ELI5从scikit-learn了解文本处理实用程序,并且可以相应地突出...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

lightgbm特征重要性