精华内容
下载资源
问答
  • 特征重要性分析

    千次阅读 2018-03-02 11:43:45
    1 from sklearn.tree import DecisionTreeRegressor 2 from sklearn.ensemble import RandomForestRegressor 3 import numpy as np 4 5 from sklearn.externals.joblib import Memory 6 from sklearn.datase...
      1 from sklearn.tree import DecisionTreeRegressor
      2 from sklearn.ensemble import RandomForestRegressor
      3 import numpy as np
      4 
      5 from sklearn.externals.joblib import Memory
      6 from sklearn.datasets import load_svmlight_file
      7 
      8 import sys
      9 import os
     10 
     11 X,y = load_svmlight_file(sys.argv[1])
     12 
     13 names = open("feature_name").readlines()
     14 names = [s.strip() for s in names]
     15 
     16 
     17 rf = RandomForestRegressor(oob_score=True)
     18 clf = rf.fit(X, y)
     19 
     20 print "oob score:",rf.oob_score_
     21 
     22 print "Features sorted by their score:"
     23 
     24 res =sorted(zip(map(lambda x: round(x, 4), clf.feature_importances_), names), reverse=True)                                                                            
     25 
     26 
     27 for item in res:
     28     print "%s\t%s" %(item[0],item[1])

     29 

    oob score: 0.300278261714
    Features sorted by their score:
    0.2961  tw_term_weight
    0.0623  dict_from_fuzzy_dict
    0.0352  tw_term_final_ctw
    0.0314  dict_from_fuzzy_must_dict
    0.023   tq_query_qerate
    0.0203  tw_term_ctw_zscore
    0.0157  idf_percent
    0.0155  pos_weighted
    0.0148  pos_weighted_norm
    0.012   tq_query_pdr
    0.0119  qp_hit_pattern_title_weight_zscore
    0.0113  tq_query_qerate_zscore
    0.0109  idf_term_idf_zscore
    0.0102  pos_bs
    0.01    term_query_avg_ctw
    0.0099  tq_query_qaw
    0.0099  qp_match_pattern_title_weight_min
    0.0094  tq_query_exact
    0.0091  term_query_idf_max
    0.009   qp_hit_pattern_weight_and_title_weight
    0.0089  tw_term_weight_zscore
    0.0089  term_query_min_weight
    0.0089  term_query_idf_sum
    0.0089  term_query_idf_avg
    0.0089  pos_boolean
    0.0088  qp_match_pattern_title_weight_max
    0.0084  qp_hit_pattern_weight_and_title_weight_zscore
    0.0083  qp_hit_pattern_title_weight
    0.0081  sq_sub_query_count
    0.008   term_query_idf_min
    0.0077  idf_after_idf
    0.0075  qp_hit_pattern_freq
    0.0074  tq_query_prev_qerate
    0.007   tp_phrase_ctw_zscore
    0.007   qp_match_pattern_max_and_weight
    0.0069  tq_query_after_qerate
    0.0068  tp_phrase_title_weight_zscore
    0.0068  tc_term_total_no_cooccur_weight
    0.0068  idf_prev_idf
    0.0067  idf
    0.0065  tw_prev_term_weight
    0.0064  pos_term_position_rate
    0.0062  tc_term_no_cooccur_max_weight
    0.0062  qp_hit_pattern_total_weight
    0.0059  tw_after_term_weight
    0.0059  tp_phrase_qp
    0.0058  tq_query_part
    0.0058  tp_phrase_pmi
    0.0057  tp_phrase_max_ctw
    0.0052  tp_phrase_max_title_weight
    0.0051  tp_phrase_min_ctw
    0.005   tp_phrase_qe
    0.005   term_query_len
    0.0049  tp_phrase_qaw
    0.0049  tp_phrase_idf
    0.0048  tp_phrase_min_title_weight
    0.0047  sq_sub_query_title_weight
    0.0046  tp_phrase_chi_square
    0.0043  term_query_count
    0.0042  tp_phrase_idf_rate
    0.0042  pos_idf
    0.004   sq_sub_query_weight_rate
    0.004   pos_ridf
    0.0039  tp_phrase_qerate
    0.0039  term_is_single_and_query_len
    0.0039  sq_sub_query_idf_rate
    0.0036  pos_term_position
    0.0034  sq_sub_query_len_rate
    0.003   tn_is_only_non_normal
    0.0029  tp_pos_in_phrase_rate
    0.0029  tc_term_total_no_cooccur_rate
    0.0028  tp_phrase_start
    0.0028  sq_sub_query_len_cover
    0.0028  qp_match_pattern_min_and_weight
    0.0026  tp_phrase_literal_size
    0.0024  tw_term_is_prev_max_weight
    0.002   pos_term_literal_size
    0.0019  tp_phrase_count
    0.0019  tn_term_after_is_place
    0.0018  dep_tree_siblings_num
    0.0017  term_query_term_num
    0.0015  tc_term_no_cooccur_num
    0.0014  tc_term_average_query_pmi
    0.0012  tw_ctw_quarter_order
    0.001   tw_term_weight_quarter_order
    0.0009  tp_phrase_tn
    0.0009  tn_has_synom
    0.0009  tc_term_no_cooccur_no_imp
    0.0009  idf_quarter_order
    0.0008  pos_term_after_is_single
    0.0008  pos_is_after_stop
    0.0008  is_rpath_notional_verb
    0.0008  has_same_role_with_neighbor
    0.0007  tn_term_is_entity
    0.0007  qw_is_question_word
    0.0007  pos_term_not_cont_single
    0.0007  is_min_pos_weighted
    0.0007  is_after_min_pos_bs
    0.0006  tc_term_average_imp_pmi
    0.0006  sq_is_in_sub_query
    0.0006  qw_term_after_question_word
    0.0006  pos_term_wgap
    0.0006  pos_is_wgap_eq_term_len
    0.0006  pos_is_last_back_stop
    0.0006  is_pos_tag_functional_term
    0.0006  is_bpath_notional_verb
    0.0006  is_apath_notional_verb
    0.0006  is_after_max_pos_weighted
    0.0006  idf_is_three_term_min_idf
    0.0005  tp_is_phrase_max_ctw
    0.0005  tp_is_adj_prev_phrase
    0.0005  tp_is_adj_after_phrase
    0.0005  tn_is_chn_mix
    0.0005  tc_term_prev_pmi
    0.0005  pos_term_prev_is_single
    0.0005  is_special_noun
    0.0005  is_prev_min_pos_bs
    0.0005  is_prev_max_pos_weighted
    0.0005  is_prev_max_pos_ridf
    0.0005  is_min_pos_weighted_noun
    0.0005  is_min_pos_boolean
    0.0005  is_max_pos_bs
    0.0005  is_max_pos_boolean
    0.0004  tw_term_is_after_max_weight
    0.0004  tw_is_three_min_weight
    0.0004  tp_is_phrase_min_ctw
    0.0004  tp_is_phrase_max_title_weight
    0.0004  tn_term_prev_is_place
    0.0004  tn_term_is_name
    0.0004  tc_term_after_pmi
    0.0004  sq_is_between_sub_query
    0.0004  qp_match_pattern_is_min
    0.0004  is_rpath_notional_head
    0.0004  is_prev_max_pos_idf
    0.0004  is_pos_rel_notional_verb
    0.0004  is_min_pos_ridf_noun
    0.0004  is_min_pos_idf
    0.0004  is_min_pos_bs
    0.0004  is_max_pos_weighted
    0.0004  is_max_pos_bs_noun
    0.0004  is_max_pos_bs_in_siblings
    0.0004  idf_is_prev_max_idf
    0.0004  idf_is_min_idf
    0.0004  has_same_role_in_siblings
    0.0003  tw_is_min_weight
    0.0003  tp_is_phrase_min_title_weight
    0.0003  tn_term_is_place
    0.0003  tn_is_all_en
    0.0003  tn_is_all_ascii
    0.0003  sq_is_phrase_between_sub_query
    0.0003  qp_match_pattern_is_max
    0.0003  is_upward_rel_notional_verb
    0.0003  is_upward_rel_functional_term
    0.0003  is_min_pos_ridf_in_siblings
    0.0003  is_min_pos_idf_noun
    0.0003  is_min_pos_idf_in_siblings
    0.0003  is_min_pos_bs_in_siblings
    0.0003  is_max_pos_ridf_in_siblings
    0.0003  is_max_pos_idf_in_siblings
    0.0003  is_max_pos_idf
    0.0003  is_after_max_pos_idf
    0.0003  idf_is_max_idf
    0.0003  idf_is_after_max_idf
    0.0003  dict_is_end
    0.0003  dict_is_begin
    0.0002  term_query_is_all_ascii
    0.0002  qp_is_match_pattern
    0.0002  pos_is_start_term
    0.0002  pos_is_end_term
    0.0002  is_spath_notional_verb
    0.0002  is_min_pos_ridf
    0.0002  is_max_pos_ridf
    0.0002  is_after_max_pos_ridf
    0.0001  tw_is_max_weight
    0.0001  tp_has_phrase
    0.0001  qp_is_hit_pattern
    0.0001  is_tpath_notional_verb
    0.0001  is_tpath_notional_object
    0.0     tp_phrase_sum_weight
    0.0     is_upward_rel_functional_noun
    0.0     is_spath_functional_noun
    0.0     is_rpath_notional_object
    0.0     is_pos_rel_functional_noun
    0.0     is_min_pos_weighted_in_siblings
    0.0     is_max_pos_weighted_in_siblings
    0.0     is_bpath_functional_noun

    0.0     is_apath_functional_noun

    同义词模型

    3 0.0379  20 trigram_search_score_ratio
      4 0.0351  12 chi_with_origin_rank
      5 0.0292  39 lsi_core_context
      6 0.0285  11 pmi_with_origin_rank
      7 0.0246  60 glsa_related_context
      8 0.0216  13 llr_with_origin_rank
      9 0.0197  59 glsa_third_order_context
     10 0.0193  6 logdice_score
     11 0.0192  41 lsi_second_order_context_ratio
     12 0.0191  15 trigram_match_score                                                                                                                                         
     13 0.0189  53 lsi_related_deviation
     14 0.0187  61 glsa_core_context
     15 0.0182  42 lsi_third_order_context_ratio
     16 0.018   35 lsi_first_order_context
     17 0.0168  55 glsa_with_origin
     18 0.0168  54 lsi_core_deviation
     19 0.0164  56 glsa_with_origin_rank
     20 0.0159  38 lsi_related_context
     21 0.0158  16 trigram_match_score_ratio
     22 0.015   43 lsi_related_context_ratio
     23 0.0148  45 lsi_first_order_context_rank
     24 0.0143  47 lsi_third_order_context_rank
     25 0.014   36 lsi_second_order_context
     26 0.0139  46 lsi_second_order_context_rank
     27 0.0138  40 lsi_first_order_context_ratio
     28 0.0137  44 lsi_core_context_ratio
     29 0.0135  37 lsi_third_order_context
     30 0.0134  21 trigram_search_score_rank
     31 0.0128  27 language_model_score_rank
     32 0.0117  49 lsi_core_context_rank
     33 0.0116  3 pmi_normed_origin
     34 0.0116  23 fourgram_search_score_ratio
     35 0.0115  69 glsa_third_order_context_rank
     36 0.0114  30 sentence_cooccur_rate
     37 0.0111  66 glsa_core_context_ratio
     38 0.0111  48 lsi_related_context_rank
     39 0.011   5 dice_score
     40 0.0106  1 pmi
     41 0.0104  10 tscore
     42 0.0098  24 fourgram_search_score_rank
     43 0.0097  14 tscore_with_origin_rank
     44 0.0095  52 lsi_third_order_deviation
     45 0.0092  22 fourgram_search_score
     46 0.009   28 local_trigram_count_ratio
     47 0.0089  75 glsa_related_deviation
     48 0.0088  8 log_likelihood
     49 0.0088  25 language_model_score
     50 0.0086  50 lsi_first_order_deviation
     51 0.0086  4 pmi_normed_candidate


    展开全文
  • 卷积神经网络特征重要性分析及增强特征选择模型_卢泓宇张敏
  • 宅在家里不能回去工作,...但是在GEE之前并没有相关API可以做特征重要性分析,最新的API更新后GEE也可以做特征重要性分析了。 1、目前常用的包含特征重要信息分析的分类方法包括: (1)决策树 ee.Classifier.s...

        宅在家里不能回去工作,还是学习一下GEE吧!借用网友绘制的图片,加油,一切都会好起来的!

     

        之前在GEE中做随机森林分类时候,很多人都在问如何做特征重要性分析?但是在GEE之前并没有相关API可以做特征重要性分析,最新的API更新后GEE也可以做特征重要性分析了。

     

    1、目前常用的包含特征重要信息分析的分类方法包括:

    (1)决策树

    ee.Classifier.smileCart(maxNodes, minLeafPopulation)

    (2)随机森林

    ee.Classifier.smileRandomForest(numberOfTrees, variablesPerSplit, minLeafPopulation, bagFraction, maxNodes, seed)

        这两个方法和之前的分类决策树和随机森林分类方法参数非常类似,只不过调用这两个定义方法在使用explain()方法就可以得到每个分类特征重要性的信息。

     

    2、得到特征重要性的API方法:

        也就是之前在分类器中的方法explain,这个方法是最开始就有的,只不过是最近GEE官方加入了特征重要性的分析返回信息,下面通过一个具体例子说明一下如何使用以及具体输出。

     

    具体代码:

    var roi =
    
        /* color: #d63000 */
    
        /* shown: false */
    
        /* displayProperties: [
    
          {
    
            "type": "rectangle"
    
          }
    
        ] */
    
        ee.Geometry.Polygon(
    
            [[[114.23790821489501, 36.43657462800738],
    
              [114.23790821489501, 36.29834769127675],
    
              [114.49265369829345, 36.29834769127675],
    
              [114.49265369829345, 36.43657462800738]]], null, false),
    
        crop =
    
        /* color: #98ff00 */
    
        /* shown: false */
    
        ee.FeatureCollection(
    
            [ee.Feature(
    
                ee.Geometry.Point([114.31343922075439, 36.356156419842804]),
    
                {
    
                  "type": 0,
    
                  "system:index": "0"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.31056389269042, 36.35499859187555]),
    
                {
    
                  "type": 0,
    
                  "system:index": "1"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.31236633714843, 36.3529248270982]),
    
                {
    
                  "type": 0,
    
                  "system:index": "2"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.32159313615966, 36.35461840580203]),
    
                {
    
                  "type": 0,
    
                  "system:index": "3"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.32348141130615, 36.35638107103549]),
    
                {
    
                  "type": 0,
    
                  "system:index": "4"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.32936081346679, 36.35589720612248]),
    
                {
    
                  "type": 0,
    
                  "system:index": "5"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.33515438493896, 36.35565527253804]),
    
                {
    
                  "type": 0,
    
                  "system:index": "6"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.33545479234863, 36.35855842592195]),
    
                {
    
                  "type": 0,
    
                  "system:index": "7"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.29468521532226, 36.35679580999553]),
    
                {
    
                  "type": 0,
    
                  "system:index": "8"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.29979214128662, 36.34922647614173]),
    
                {
    
                  "type": 0,
    
                  "system:index": "9"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.28871998247314, 36.3387180531404]),
    
                {
    
                  "type": 0,
    
                  "system:index": "10"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.28279766496826, 36.33833778756726]),
    
                {
    
                  "type": 0,
    
                  "system:index": "11"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39553627428222, 36.3299369018726]),
    
                {
    
                  "type": 0,
    
                  "system:index": "12"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39725288805175, 36.32997147527504]),
    
                {
    
                  "type": 0,
    
                  "system:index": "13"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39712414201904, 36.32796619257241]),
    
                {
    
                  "type": 0,
    
                  "system:index": "14"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39918407854248, 36.3291762831369]),
    
                {
    
                  "type": 0,
    
                  "system:index": "15"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39845451769042, 36.3274475765775]),
    
                {
    
                  "type": 0,
    
                  "system:index": "16"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.40467724260498, 36.32900341420687]),
    
                {
    
                  "type": 0,
    
                  "system:index": "17"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.40480598863769, 36.32734385296429]),
    
                {
    
                  "type": 0,
    
                  "system:index": "18"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38210377153564, 36.33612529650057]),
    
                {
    
                  "type": 0,
    
                  "system:index": "19"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38034424242187, 36.336194437797644]),
    
                {
    
                  "type": 0,
    
                  "system:index": "20"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38098797258544, 36.34041194086619]),
    
                {
    
                  "type": 0,
    
                  "system:index": "21"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38785442766357, 36.337473540724005]),
    
                {
    
                  "type": 0,
    
                  "system:index": "22"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38532242235351, 36.34227863160822]),
    
                {
    
                  "type": 0,
    
                  "system:index": "23"
    
                })]),
    
        nocrop =
    
        /* color: #0b4a8b */
    
        /* shown: false */
    
        ee.FeatureCollection(
    
            [ee.Feature(
    
                ee.Geometry.Point([114.36832794603515, 36.344663782445146]),
    
                {
    
                  "type": 1,
    
                  "system:index": "0"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.37463650163818, 36.345078583829164]),
    
                {
    
                  "type": 1,
    
                  "system:index": "1"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.37742599901367, 36.34576991455905]),
    
                {
    
                  "type": 1,
    
                  "system:index": "2"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.378026813833, 36.34860430638123]),
    
                {
    
                  "type": 1,
    
                  "system:index": "3"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.37386402544189, 36.35009059256129]),
    
                {
    
                  "type": 1,
    
                  "system:index": "4"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.36987289842773, 36.352198996374725]),
    
                {
    
                  "type": 1,
    
                  "system:index": "5"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.37695393022705, 36.351887923993054]),
    
                {
    
                  "type": 1,
    
                  "system:index": "6"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.3797005122583, 36.35392715363849]),
    
                {
    
                  "type": 1,
    
                  "system:index": "7"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.37352070268798, 36.35627738595022]),
    
                {
    
                  "type": 1,
    
                  "system:index": "8"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.31785950121093, 36.34438724696162]),
    
                {
    
                  "type": 1,
    
                  "system:index": "9"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.31657204088378, 36.34345393245458]),
    
                {
    
                  "type": 1,
    
                  "system:index": "10"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.34390911516357, 36.33512274079625]),
    
                {
    
                  "type": 1,
    
                  "system:index": "11"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.35094723161865, 36.33723154988948]),
    
                {
    
                  "type": 1,
    
                  "system:index": "12"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.35309299883056, 36.337058698833104]),
    
                {
    
                  "type": 1,
    
                  "system:index": "13"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.35296425279785, 36.33501902740074]),
    
                {
    
                  "type": 1,
    
                  "system:index": "14"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.41952058729305, 36.35091929703152]),
    
                {
    
                  "type": 1,
    
                  "system:index": "15"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.41966006216182, 36.3516321782695]),
    
                {
    
                  "type": 1,
    
                  "system:index": "16"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.41982099470272, 36.35252219053154]),
    
                {
    
                  "type": 1,
    
                  "system:index": "17"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.42009458002224, 36.35383558809808]),
    
                {
    
                  "type": 1,
    
                  "system:index": "18"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.42027697023525, 36.35499343336394]),
    
                {
    
                  "type": 1,
    
                  "system:index": "19"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.42028233465328, 36.35609509850472]),
    
                {
    
                  "type": 1,
    
                  "system:index": "20"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.42228326257839, 36.35603461533285]),
    
                {
    
                  "type": 1,
    
                  "system:index": "21"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.42357072290554, 36.35606053669799]),
    
                {
    
                  "type": 1,
    
                  "system:index": "22"
    
                })]),
    
        water =
    
        /* color: #ffc82d */
    
        /* shown: false */
    
        ee.FeatureCollection(
    
            [ee.Feature(
    
                ee.Geometry.Point([114.3321717685144, 36.3306024371752]),
    
                {
    
                  "type": 2,
    
                  "system:index": "0"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.33210739549804, 36.333592954210076]),
    
                {
    
                  "type": 2,
    
                  "system:index": "1"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.28854832109619, 36.41266166922327]),
    
                {
    
                  "type": 2,
    
                  "system:index": "2"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.29610142168212, 36.40879346635716]),
    
                {
    
                  "type": 2,
    
                  "system:index": "3"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.28580173906494, 36.40547771059803]),
    
                {
    
                  "type": 2,
    
                  "system:index": "4"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.29541477617431, 36.40160915003326]),
    
                {
    
                  "type": 2,
    
                  "system:index": "5"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.3057144587915, 36.40547771059803]),
    
                {
    
                  "type": 2,
    
                  "system:index": "6"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.29953464922119, 36.39829308768715]),
    
                {
    
                  "type": 2,
    
                  "system:index": "7"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39435610231533, 36.3617846267207]),
    
                {
    
                  "type": 2,
    
                  "system:index": "8"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39429172929897, 36.361179837099506]),
    
                {
    
                  "type": 2,
    
                  "system:index": "9"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38845524248256, 36.35940000037548]),
    
                {
    
                  "type": 2,
    
                  "system:index": "10"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38152441438808, 36.35701530096524]),
    
                {
    
                  "type": 2,
    
                  "system:index": "11"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.38133129533901, 36.35653143999478]),
    
                {
    
                  "type": 2,
    
                  "system:index": "12"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.39965614732876, 36.36371992192421]),
    
                {
    
                  "type": 2,
    
                  "system:index": "13"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.40693029817714, 36.3668473954689]),
    
                {
    
                  "type": 2,
    
                  "system:index": "14"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.41094288286342, 36.36890351124372]),
    
                {
    
                  "type": 2,
    
                  "system:index": "15"
    
                }),
    
            ee.Feature(
    
                ee.Geometry.Point([114.40238127168789, 36.36840244602017]),
    
                {
    
                  "type": 2,
    
                  "system:index": "16"
    
                })]);
    
    
    
    //监督分类
    
    Map.centerObject(roi, 11);
    
    Map.addLayer(roi, {color: "red"}, "roi", false);
    
    var sampleData = crop.merge(nocrop).merge(water);
    
    
    
    //Landsat8 SR数据去云
    
    function rmCloud(image) {
    
      var cloudShadowBitMask = (1 << 3);
    
      var cloudsBitMask = (1 << 5);
    
      var qa = image.select("pixel_qa");
    
      var mask = qa.bitwiseAnd(cloudShadowBitMask).eq(0)
    
                     .and(qa.bitwiseAnd(cloudsBitMask).eq(0));
    
      return image.updateMask(mask);
    
    }
    
    
    
    //缩放
    
    function scaleImage(image) {
    
      var time_start = image.get("system:time_start");
    
      image = image.multiply(0.0001);
    
      image = image.set("system:time_start", time_start);
    
      return image;
    
    }
    
    
    
    //NDVI
    
    function NDVI(image) {
    
      return image.addBands(
    
        image.normalizedDifference(["B5", "B4"])
    
             .rename("NDVI"));
    
    }
    
    //NDWI
    
    function NDWI(image) {
    
      return image.addBands(
    
        image.normalizedDifference(["B3", "B5"])
    
             .rename("NDWI"));
    
    }
    
    //NDBI
    
    function NDBI(image) {
    
      return image.addBands(
    
        image.normalizedDifference(["B6", "B5"])
    
             .rename("NDBI"));
    
    }
    
    var l8Col = ee.ImageCollection("LANDSAT/LC08/C01/T1_SR")
    
                  .filterBounds(roi)
    
                  .filterDate("2018-1-1", "2019-1-1")
    
                  .map(rmCloud)
    
                  .map(scaleImage)
    
                  .map(NDVI)
    
                  .map(NDWI)
    
                  .map(NDBI);
    
    var bands = [
    
      "B1", "B2", "B3", "B4", "B5", "B6", "B7",
    
      "NDBI", "NDWI", "NDVI"
    
    ];
    
    var l8Image = l8Col.median()
    
                       .clip(roi)
    
                       .select(bands);
    
    var rgbVisParam = {
    
      min: 0,
    
      max: 0.3,
    
      bands: ["B4", "B3", "B2"]
    
    };
    
    Map.addLayer(l8Image, rgbVisParam, "l8Image");
    
    //生成监督分类训练使用的样本数据
    
    var training = l8Image.sampleRegions({
    
      collection: sampleData,
    
      properties: ["type"],
    
      scale: 30
    
    });
    
    //初始化分类器
    
    // var classifier = ee.Classifier.smileCart().train({
    
    //   features: training,
    
    //   classProperty: "type",
    
    //   inputProperties: bands
    
    // });
    
    var classifier = ee.Classifier.smileRandomForest(10).train({
    
      features: training,
    
      classProperty: "type",
    
      inputProperties: bands
    
    });
    
    print(classifier.explain());
    
    
    //影像数据调用classify利用训练数据训练得到分类结果
    
    var classified = l8Image.classify(classifier);
    
    //训练结果的混淆矩阵
    
    var trainAccuracy = classifier.confusionMatrix();
    
    Map.addLayer(classified, {min:0, max:2, palette: ["green", "orange", "blue"]}, "classify");

     

    代码分析:

    (1)这段代码做的是一个简单的监督分类,通过自己标注的样本将影像分成3大类(作物、非作物和水),样本由于是我做测试随机标注的,所以测试精度和分类准确度不高。

    (2)和之前的分类代码相比较,这里只是更换了分类方法,比如随机森林我使用的是smileRandomForest方法,参数和之前的方法的参数类似,这里只是简单设置了树的个数为10。

    (3)然后对分类器调用explain方法就可以查看特征重要性信息,输出结果如下面所示。

     

    运行结果:

        比如使用ee.Classifier.smileRandomForest()方法做的分类结果,使用explain后的信息如下图:

     


    大家如果有问题需要交流或者有项目需要合作,可以微信联系我,加微信好友请留言加上“GEE”。

    知乎专栏:https://zhuanlan.zhihu.com/c_123993183

    CSDN:https://blog.csdn.net/shi_weihappy

    微信号:shi_weihappy

    展开全文
  • 使用诸如梯度增强之类的决策树方法的集成的好处是,它们可以从训练有素的预测模型中自动提供特征重要性的估计。在本文中,您将发现如何使用Python中的XGBoost库来估计特征对于预测性建模问...

    使用诸如梯度增强之类的决策树方法的集成的好处是,它们可以从训练有素的预测模型中自动提供特征重要性的估计。

    在本文中,您将发现如何使用Python中的XGBoost库来估计特征对于预测性建模问题的重要性,阅读这篇文章后,您将知道:

    • 如何使用梯度提升算法计算特征重要性。

    • 如何绘制由XGBoost模型计算的Python中的特征重要性。

    • 如何使用XGBoost计算的特征重要性来执行特征选择。

    梯度提升中的特征重要性

    使用梯度增强的好处是,在构建增强后的树之后,检索每个属性的重要性得分相对简单。通常,重要性提供了一个分数,该分数指示每个特征在模型中构建增强决策树时的有用性或价值。用于决策树的关键决策使用的属性越多,其相对重要性就越高。

    此重要性是针对数据集中的每个属性明确计算得出的,从而可以对属性进行排名并进行相互比较。单个决策树的重要性是通过每个属性拆分点提高性能指标的数量来计算的,并由节点负责的观察次数来加权。性能度量可以是用于选择拆分点的纯度(基尼系数),也可以是其他更特定的误差函数。然后,将特征重要性在模型中所有决策树之间平均。有关如何在增强型决策树中计算特征重要性的更多技术信息,请参见《统计学习的要素:数据挖掘,推理和预测》(第367页)第10.13.1节“预测变量的相对重要性”。另外,请参见Matthew Drury对StackOverflow问题“ Boosting的相对变量重要性”的回答,在此他提供了非常详细和实用的答案。

    手动绘制特征重要性

    训练有素的XGBoost模型会自动计算出您的预测建模问题中的特征重要性。这些重要性分数可在训练模型的feature_importances_成员变量中获得。例如,可以按如下所示直接打印它们:

    print(model.feature_importances_)
    

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

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

    我们可以通过在皮马印第安人发病的糖尿病数据集上训练XGBoost模型并根据计算出的特征重要性创建条形图来证明这一点。

    下载数据集并将其放置在当前工作目录中。

    数据集文件:

    https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.csv

    数据集详细信息:

    https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.names

    # plot feature importance manually
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from matplotlib import pyplot
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    y = dataset[:,8]
    # 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.089701    0.17109634  0.08139535  0.04651163  0.10465116  0.2026578 0.1627907   0.14119601]
    

    我们还获得了相对重要性的条形图。

    该图的缺点是要素按其输入索引而不是其重要性排序。我们可以在绘制之前对特征进行排序。

    值得庆幸的是,有一个内置的绘图函数可以帮助我们。

    使用内置XGBoost特征重要性图XGBoost库提供了一个内置函数,可以按重要性顺序绘制要素。该函数称为plot_importance(),可以按以下方式使用:

    # plot feature importance
    plot_importance(model)
    pyplot.show()
    

    例如,以下是完整的代码清单,其中使用内置的plot_importance()函数绘制了Pima Indians数据集的特征重要性。

    # plot feature importance using built-in function
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from xgboost import plot_importance
    from matplotlib import pyplot
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    y = dataset[:,8]
    # fit model no training data
    model = XGBClassifier()
    model.fit(X, y)
    # plot feature importance
    plot_importance(model)
    pyplot.show()
    

    注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。

    运行该示例将为我们提供更有用的条形图。

    您可以看到,要素是根据它们在F0至F7的输入数组(X)中的索引自动命名的。手动将这些索引映射到问题描述中的名称,可以看到该图显示F5(体重指数)具有最高的重要性,而F3(皮肤褶皱厚度)具有最低的重要性。

    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)
    

    出于兴趣,我们可以测试多个阈值,以根据特征重要性选择特征。具体来说,每个输入变量的特征重要性,从本质上讲,使我们能够按重要性测试每个特征子集,从所有特征开始,到具有最重要特征的子集结束。

    下面提供了完整的代码清单:

    # use feature importance for feature selection
    from numpy import loadtxt
    from numpy import sort
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.feature_selection import SelectFromModel
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    # 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 on all training data
    model = XGBClassifier()
    model.fit(X_train, y_train)
    # 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 = 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))
    

    请注意,如果您使用的是XGBoost 1.0.2(可能还有其他版本),则XGBClassifier类中存在一个错误,该错误会导致错误:

    KeyError: 'weight'
    

    这可以通过使用自定义XGBClassifier类来解决,该类为coef_属性返回None。下面列出了完整的示例。

    # use feature importance for feature selection, with fix for xgboost 1.0.2
    from numpy import loadtxt
    from numpy import sort
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.feature_selection import SelectFromModel
     
    # define custom class to fix bug in xgboost 1.0.2
    class MyXGBClassifier(XGBClassifier):
     @property
     def coef_(self):
      return None
     
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    # 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 on all training data
    model = MyXGBClassifier()
    model.fit(X_train, y_train)
    # make predictions for test data and evaluate
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy: %.2f%%" % (accuracy * 100.0))
    # Fit model using each importance as a threshold
    thresholds = 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)
     predictions = selection_model.predict(select_X_test)
     accuracy = accuracy_score(y_test, predictions)
     print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (thresh, select_X_train.shape[1], accuracy*100.0))
    

    注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。考虑运行该示例几次并比较平均结果。

    运行此示例将打印以下输出。

    Accuracy: 77.95%
    Thresh=0.071, n=8, Accuracy: 77.95%
    Thresh=0.073, n=7, Accuracy: 76.38%
    Thresh=0.084, n=6, Accuracy: 77.56%
    Thresh=0.090, n=5, Accuracy: 76.38%
    Thresh=0.128, n=4, Accuracy: 76.38%
    Thresh=0.160, n=3, Accuracy: 74.80%
    Thresh=0.186, n=2, Accuracy: 71.65%
    Thresh=0.208, n=1, Accuracy: 63.78%
    

    我们可以看到,模型的性能通常随所选特征的数量而降低。

    在此问题上,需要权衡测试集精度的特征,我们可以决定采用较不复杂的模型(较少的属性,例如n = 4),并接受估计精度的适度降低,从77.95%降至76.38%。

    这可能是对这么小的数据集的洗礼,但是对于更大的数据集并使用交叉验证作为模型评估方案可能是更有用的策略。

    者:沂水寒城,CSDN博客专家,个人研究方向:机器学习、深度学习、NLP、CV

    Blog: http://yishuihancheng.blog.csdn.net

    赞 赏 作 者

    更多阅读

    用 XGBoost 进行时间序列预测

    5分钟掌握 Python 随机爬山算法

    5分钟完全读懂关联规则挖掘算法

    特别推荐


    点击下方阅读原文加入社区会员

    展开全文
  • 【翻译自 : Feature Importance and Feature Selection With ... 使用诸如梯度增强之类的决策树方法的集成的好处是,它们可以从训练有素的预测模型中自动提供特征重要性的估计。 在本文中,您将发现如何使用P...

            【翻译自 : Feature Importance and Feature Selection With XGBoost in Python

            【说明:Jason Brownlee PhD大神的文章个人很喜欢,所以闲暇时间里会做一点翻译和学习实践的工作,这里是相应工作的实践记录,希望能帮到有需要的人!】

             使用诸如梯度增强之类的决策树方法的集成的好处是,它们可以从训练有素的预测模型中自动提供特征重要性的估计。

            在本文中,您将发现如何使用Python中的XGBoost库来估计特征对于预测性建模问题的重要性,阅读这篇文章后,您将知道:

    如何使用梯度提升算法计算特征重要性。
    如何绘制由XGBoost模型计算的Python中的特征重要性。
    如何使用XGBoost计算的特征重要性来执行特征选择。

    梯度提升中的特征重要性

           使用梯度增强的好处是,在构建增强后的树之后,检索每个属性的重要性得分相对简单。通常,重要性提供了一个分数,该分数指示每个特征在模型中构建增强决策树时的有用性或价值。用于决策树的关键决策使用的属性越多,其相对重要性就越高。

           此重要性是针对数据集中的每个属性明确计算得出的,从而可以对属性进行排名并进行相互比较。单个决策树的重要性是通过每个属性拆分点提高性能指标的数量来计算的,并由节点负责的观察次数来加权。性能度量可以是用于选择拆分点的纯度(基尼系数),也可以是其他更特定的误差函数。然后,将特征重要性在模型中所有决策树之间平均。有关如何在增强型决策树中计算特征重要性的更多技术信息,请参见《统计学习的要素:数据挖掘,推理和预测》(第367页)第10.13.1节“预测变量的相对重要性”。另外,请参见Matthew Drury对StackOverflow问题“ Boosting的相对变量重要性”的回答,在此他提供了非常详细和实用的答案。

    手动绘制特征重要性

            训练有素的XGBoost模型会自动计算出您的预测建模问题中的特征重要性。这些重要性分数可在训练模型的feature_importances_成员变量中获得。例如,可以按如下所示直接打印它们:

    print(model.feature_importances_)

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

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

            我们可以通过在皮马印第安人发病的糖尿病数据集上训练XGBoost模型并根据计算出的特征重要性创建条形图来证明这一点。

          下载数据集并将其放置在当前工作目录中。

    数据集文件
    数据集详细信息

    # plot feature importance manually
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from matplotlib import pyplot
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    y = dataset[:,8]
    # 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.089701    0.17109634  0.08139535  0.04651163  0.10465116  0.2026578 0.1627907   0.14119601]

           我们还获得了相对重要性的条形图。

              该图的缺点是要素按其输入索引而不是其重要性排序。 我们可以在绘制之前对特征进行排序。

             值得庆幸的是,有一个内置的绘图函数可以帮助我们。

             使用内置XGBoost特征重要性图XGBoost库提供了一个内置函数,可以按重要性顺序绘制要素。该函数称为plot_importance(),可以按以下方式使用:

    # plot feature importance
    plot_importance(model)
    pyplot.show()

           例如,以下是完整的代码清单,其中使用内置的plot_importance()函数绘制了Pima Indians数据集的特征重要性。

    # plot feature importance using built-in function
    from numpy import loadtxt
    from xgboost import XGBClassifier
    from xgboost import plot_importance
    from matplotlib import pyplot
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    y = dataset[:,8]
    # fit model no training data
    model = XGBClassifier()
    model.fit(X, y)
    # plot feature importance
    plot_importance(model)
    pyplot.show()

            注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。

           运行该示例将为我们提供更有用的条形图。

            您可以看到,要素是根据它们在F0至F7的输入数组(X)中的索引自动命名的。手动将这些索引映射到问题描述中的名称,可以看到该图显示F5(体重指数)具有最高的重要性,而F3(皮肤褶皱厚度)具有最低的重要性。

    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)

           出于兴趣,我们可以测试多个阈值,以根据特征重要性选择特征。 具体来说,每个输入变量的特征重要性,从本质上讲,使我们能够按重要性测试每个特征子集,从所有特征开始,到具有最重要特征的子集结束。

           下面提供了完整的代码清单:

    # use feature importance for feature selection
    from numpy import loadtxt
    from numpy import sort
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.feature_selection import SelectFromModel
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    # 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 on all training data
    model = XGBClassifier()
    model.fit(X_train, y_train)
    # 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 = 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))

           请注意,如果您使用的是XGBoost 1.0.2(可能还有其他版本),则XGBClassifier类中存在一个错误,该错误会导致错误:

    KeyError: 'weight'

              这可以通过使用自定义XGBClassifier类来解决,该类为coef_属性返回None。下面列出了完整的示例。

    # use feature importance for feature selection, with fix for xgboost 1.0.2
    from numpy import loadtxt
    from numpy import sort
    from xgboost import XGBClassifier
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    from sklearn.feature_selection import SelectFromModel
    
    # define custom class to fix bug in xgboost 1.0.2
    class MyXGBClassifier(XGBClassifier):
    	@property
    	def coef_(self):
    		return None
    
    # load data
    dataset = loadtxt('pima-indians-diabetes.csv', delimiter=",")
    # split data into X and y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    # 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 on all training data
    model = MyXGBClassifier()
    model.fit(X_train, y_train)
    # make predictions for test data and evaluate
    predictions = model.predict(X_test)
    accuracy = accuracy_score(y_test, predictions)
    print("Accuracy: %.2f%%" % (accuracy * 100.0))
    # Fit model using each importance as a threshold
    thresholds = 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)
    	predictions = selection_model.predict(select_X_test)
    	accuracy = accuracy_score(y_test, predictions)
    	print("Thresh=%.3f, n=%d, Accuracy: %.2f%%" % (thresh, select_X_train.shape[1], accuracy*100.0))

            注意:由于算法或评估程序的随机性,或者数值精度的差异,您的结果可能会有所不同。 考虑运行该示例几次并比较平均结果。

           运行此示例将打印以下输出。

    Accuracy: 77.95%
    Thresh=0.071, n=8, Accuracy: 77.95%
    Thresh=0.073, n=7, Accuracy: 76.38%
    Thresh=0.084, n=6, Accuracy: 77.56%
    Thresh=0.090, n=5, Accuracy: 76.38%
    Thresh=0.128, n=4, Accuracy: 76.38%
    Thresh=0.160, n=3, Accuracy: 74.80%
    Thresh=0.186, n=2, Accuracy: 71.65%
    Thresh=0.208, n=1, Accuracy: 63.78%

            我们可以看到,模型的性能通常随所选特征的数量而降低。

           在此问题上,需要权衡测试集精度的特征,我们可以决定采用较不复杂的模型(较少的属性,例如n = 4),并接受估计精度的适度降低,从77.95%降至76.38%。

           这可能是对这么小的数据集的洗礼,但是对于更大的数据集并使用交叉验证作为模型评估方案可能是更有用的策略。

    展开全文
  • 回归模型 中 特征 重要性 分析

    千次阅读 2019-12-12 23:54:21
    1.树模型,建立好模型以后,看那个属性里根节点越近则越重要。模型会自带一些输出重要属性的方法。 2.线性模型,模型一般可以直接输出参数,参数越大越重要。 3.利用互信息等类似的方法可以做,sklearn有,scipy里面...
  • 特征重要性指标评估三种常用的方式: ①gain 增益意味着相应的特征对通过对模型中的每个树采取每个特征的贡献而计算出的模型的相对贡献。与其他特征相比,此度量值的较高值意味着它对于生成预测更为重要。 ②cover...
  • 通过重要性抑制分析进行特征组合
  • 训练决策树的时候发现,多次训练结束的特征重要性不一样,最...分析是特征共线性导致的,这三个特征的相关关系是0.99,业务逻辑上,三者也确实是正相关的,因此剔除其中两个,剔除之后特征重要性就未定了许多 ...
  • 基于 UCI 葡萄酒数据,使用随机森林进行特征重要性分析,这些数据是对意大利同一地区种植的三种不同品种葡萄酒的化学分析结果,分析确定了三种葡萄酒中13种成分的含量,数据的第一列是葡萄酒的类别
  • 在这个例子中,我使用的是虹膜数据:在此示例之前,请注意使用PCA作为特征选择工具时的基本思想是根据系数(载荷)的大小(从绝对值的最大值到最小值)选择变量.有关更多详细信息,请参阅情节后的最后一段.import numpy as ...
  • 以新浪微博为例,试图通过不同的特征选择方法与不同的分类器组合实验回答以上问题,实验结果表明特征组的选择较分类器的改进更为重要,需从内容信息、用户行为和社会关系多侧面生成特征,且特征并非越多检测效果越好...
  • 现在,我正在努力识别在简化数据集中重要的原始特征.在降维后,如何找出哪些特征重要的,哪些特征不在剩余的主要组件中?这是我的代码:from sklearn.decomposition import PCApca = PCA(n_components=8)pca.fit(sc.....
  • 通过分析现实场景下设备的移动轨迹,发现其链路持续时间互补累积分布具有幂律特征;熟悉度-频繁度分布具有节点比例差异和时间无关性特征。从社会学的角度,说明这两种分布特征符合节点移动和节点间组织关系的社会...
  • overwatch_player_DA:使用Python进行数据分析和机器学习:使用ECDF和ANOVA进行EDA,相关和回归分析,数据标准化和特征工程,通过scikit-learn支持向量回归(包括模型选择,网格搜索和特征重要性
  • 针对空间域隐写,分析了小波特征函数统计矩、高阶统计特征和差值像素邻接矩阵3组重要隐写特征间的互补,利用基于互信息准则和增强特征选择的方法进行特征融合.分析和实验表明,3组特征间存在互补,融合后能够得到更...
  • 特征工程权重分析

    2018-05-21 14:32:23
    介绍在建模过程中及在特征工程分析特征重要性时,权重的确定方法
  • 基于变量组合的变量重要性分析(viavc),用于光谱/高光谱的特征选择算法
  • Python特征分析-正态检验正态检验引入库直方图初判QQ图判断创建数据->计算均值、方差、百分位数、1/4\,2/4位数绘制数据分布图、直方图、QQ图KS检验理论推导直接用算法做KS检验 正态检验 介绍:利用观测...
  • 而正态检验,是利用利用观测数据判断总体是否服从正态分布的检验,它是统计判决中重要的一种特殊的拟合优度假设检验。 关于正态检验的方法主要有以下三种:直方图初判,QQ图判断,K-S检验。下面咱们一一了解: ...
  • 煤储层的研究对煤层气资源的评价具有重要意义,以五阳井区实钻井资料为基础,结合区域地质特征,从煤层与煤岩、煤层含气、煤层渗透、煤层孔裂隙特征、煤储层压力及煤的吸附特性等方面分析了五阳井区3号煤层的煤层气...
  • 我们不会去选择那些不相关的,例如人们口味偏辣还是偏淡,每个人每天打几个喷嚏这些因素,跟房价的涨跌几乎没有太大关系啦这就是特征选择,好的特征能够给我们带来重要的信息,因此在研究一个问题的时候,选择哪些...
  • 通过多种测试手段对该区煤层气储层的孔隙、裂隙进行了表征,分析了煤储层的孔渗特征,并探讨了煤中显微组分及不同类型的孔隙对储层孔渗的影响。研究结果表明:恩洪地区煤层厚度大,煤级适中,微小孔发育,吸附能力强,...
  • 分析某个基于脑电图的大脑编码的多媒体情感标签标注中音频信号的重要性,情感计算公开数据库DEAP被用作测试基准。基于DEAP数据库的多媒体刺激,共提取了音频特征和三类视频特征。首先仅使用视频特征基于该框架进行...
  • 目前计算特征重要性的方法有很多种。其中一些方法基于特定的模型,例如线性回归模型中的回归系数、基于树的模型中的增益重要性或神经网络中的批处理范数参数(批处理参数通常用于NN pruning,即神经网络剪枝压缩)。...
  • 通过分析,我们可以得出结论,catboost在速度和准确度方面都优于其他两家公司。在今天这个部分中,我们将深入研究catboost,探索catboost为高效建模和理解超参数提供的新特性。对于新读者来说,catboost是Yandex团队...
  • 特征工程系列: Titanic系列之原始数据分析和数据处理 ...之前的三篇博文已经进行了一次还算完整的特征工程,分析字符串类型的变量获取新变量,对数值变量进行规范化,获取派生属性并进行维规约。现在我们已...
  • 通过回归分析优化处理后的中国煤矿矿区219组实测地应力数据,对中国煤矿矿区地应力场分布特征及其与断层活动的关系有一些新的认识。目前中国煤矿矿区的地应力场类型主要以σ_H>σ_h>σ_v型和σ_H>σ_v>σ_h型为主,...
  • 利用观测数据判断总体是否服从正态分布的检验称为正态检验,它是统计判决中重要的一种特殊的拟合优度假设检验。 直方图初判 / QQ图初判 / K-S检验 1.直方图初判 import numpy as np import pandas as pd import ...
  • 通过分析控盆断裂特征,发现晚白垩世的活动断层具有明显的自相似,分维值为1.228 3,相关系数为0.999,这一分形特征产生的根本原因主要是晚白垩世秦岭造山带一级和二级活动在豫西南地区产状发生变化,产生具有分形特征...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,147
精华内容 1,258
关键字:

特征重要性分析