【特征选择】特征选择指标和方法小汇总

一、简介

1、对特征选择的指标提供计算方法和代码,包括有:相关系数、互信息、KS、IV、L1正则化、单特征模型评分、特征重要度或系数大小、boruta特征评价、递归特征消除排序。
2、提供特征选择的方法和代码:前向搜索法、遗传算法启发式搜索法,最佳特征检测法,

# 本次项目使用的数据为以下数据,
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
data['data'].shape
X,y= data['data'],data.target

# 模型使用的逻辑回归,评价指标为auc值,使用代码为封装的Feature_select类,代码附后
from tools.feature_select import Feature_select 
fs = Feature_select(X,y,lr)  

二、特征选择指标

1.皮尔森相关系数

Pearson相关系数反应了特征和标签之间的线性关系,其一个明显缺陷是,作为特征排序机制,他只对线性关系敏感。如果关系是非线性的,即便两个变量具有一一对应的关系,Pearson相关性也可能会接近0。

fs.corr()
array([-0.73002851, -0.4151853 , -0.74263553, -0.70898384, -0.35855997,
       -0.59653368, -0.69635971, -0.77661384, -0.33049855,  0.0128376 ,
       -0.56713382,  0.00830333, -0.5561407 , -0.54823594,  0.06701601,
       -0.29299924, -0.25372977, -0.40804233,  0.00652176, -0.07797242,
       -0.77645378, -0.45690282, -0.78291414, -0.73382503, -0.42146486,
       -0.59099824, -0.65961021, -0.79356602, -0.41629431, -0.32387219])

2.互信息

相比皮尔森相关系数 ,互信息能够一定程度反应特征和标签之间的非线性关系。

fs.mic()
array([0.36671567, 0.09648092, 0.40428514, 0.35976973, 0.08173721,
       0.21061423, 0.37479754, 0.44305847, 0.06671437, 0.01354967,
       0.24521911, 0.00110187, 0.278233  , 0.33920662, 0.01602095,
       0.07457715, 0.11807899, 0.12371226, 0.013367  , 0.04097258,
       0.44985384, 0.12364186, 0.47728208, 0.46426447, 0.10166035,
       0.22460362, 0.31435137, 0.43651194, 0.09544855, 0.06837461])

3.KS和IV值

KS和IV值作为风控中经常使用的两个指标,IV值更加注重特征对标签的区分能力,KS值注重模型对于标签的区分

fs.ks_iv()
(array([0.72390466, 0.45248666, 0.74467523, 0.73142276, 0.31537709,
        0.57175889, 0.75971143, 0.81985624, 0.30314201, 0.05657735,
        0.6018313 , 0.08626658, 0.5867951 , 0.70708472, 0.02433804,
        0.37730564, 0.48077533, 0.45248666, 0.00573437, 0.2043893 ,
        0.79730194, 0.44318482, 0.82737435, 0.80482004, 0.40636066,
        0.54920459, 0.70058401, 0.80290418, 0.33869774, 0.29537287]),
 array([3.78395724, 1.5824873 , 3.82087721, 3.82234285, 1.34695804,
        2.10298612, 3.00830869, 3.9745556 , 1.31276152, 1.15309762,
        2.53434592, 1.06847433, 2.80319049, 3.65151974, 1.06348267,
        1.39990837, 1.61294779, 1.59034111, 1.06672724, 1.14612131,
        4.44837968, 1.54256612, 4.58499352, 4.39469498, 1.48978388,
        2.19735313, 2.57167549, 4.37557075, 1.63321251, 1.33836142]))

4.L1正则化

L1正则化将系数w的l1范数作为惩罚项加到损失函数上,由于正则项非零,这就迫使那些弱的特征所对应的系数变成0。因此L1正则化往往会使学到的模型很稀疏(系数w经常为0),这个特性使得L1正则化成为一种很好的特征选择方法。
这里采用sklearn总lasso模型进行封装

fs.l1_select(alpha=0.01)  # alpha 系数越大,系数为0的特征越多 
array([ 0.        ,  0.00202185,  0.        ,  0.00043358, -0.        ,
       -0.        , -0.        , -0.        , -0.        , -0.        ,
       -0.        , -0.        , -0.        , -0.00125443, -0.        ,
       -0.        , -0.        , -0.        , -0.        , -0.        ,
       -0.08225553, -0.01460497, -0.01379535,  0.0007448 , -0.        ,
       -0.        , -0.06013473, -0.        , -0.        , -0.        ])

5.基于学习模型的特征评分

这种方法的思路是直接使用你要用的机器学习算法,针对每个单独的特征和响应变量建立预测模型,得出模型的评分。
其实Pearson相关系数等价于线性回归里的标准化回归系数。假如某个特征和响应变量之间的关系是非线性的,可以用基于树的方法(决策树、随机森林)、或者扩展的线性模型等。基于树的方法比较易于使用,因为他们对非线性关系的建模比较好,并且不需要太多的调试。但要注意过拟合问题,因此树的深度最好不要太大,再就是运用交叉验证。

fs.learn()
array([0.94065577, 0.77690815, 0.94993828, 0.9414743 , 0.72440823,
       0.86654102, 0.93679947, 0.96337183, 0.70027988, 0.46412392,
       0.86841319, 0.46160936, 0.87624184, 0.92835235, 0.5316104 ,
       0.72631256, 0.7815463 , 0.79461106, 0.46528705, 0.6198184 ,
       0.97066582, 0.78313947, 0.97697965, 0.97057468, 0.75707131,
       0.86194584, 0.92023563, 0.96808801, 0.73623915, 0.68791135])

6.特征重要程度或系数大小(select_from_model)

封装sklearn中Select_from_model,不过这个方法只能输出选择之后的特征,不能输出具体的评价分数,分析select_from_model代码,针对随机森林等模型,则输入其feature_important_大小。如回归模型,则输出其系数的大小。

fs.select_from_model()
array([0.66640051, 0.30333585, 0.36057931, 0.01055394, 0.02294638,
       0.11137151, 0.15632322, 0.06555693, 0.03189341, 0.00623842,
       0.02738789, 0.24660799, 0.06654065, 0.12058007, 0.00211526,
       0.02430511, 0.03371127, 0.00860147, 0.00775326, 0.00222996,
       0.7054829 , 0.37988099, 0.24474795, 0.01677032, 0.04206173,
       0.35002252, 0.43570279, 0.12673618, 0.10253126, 0.03317253])

7.boruta特征选择

boruta的思路是针对某一特征,将其值进行随机分配,形成该特征的shadow特征,通过比较原始特征和shadow特征的重要对差异,判断该特征的有效性。这一方法的优点是,形成了对照组,提出了部分不能观察到的因素造成对特征评分的误判。

fs.boruta()
[ 1.93884227e-02  2.55134195e-02 -2.22229096e-02  9.71757303e-04
  3.42173146e-04  4.67893675e-03  6.91337507e-03  2.69658857e-03
  4.77232016e-04 -2.64284804e-04 -2.54539319e-04 -2.34624522e-03
  3.69165467e-03  3.24437344e-02  3.30642361e-05  1.05415307e-03
  1.47101778e-03  3.76387825e-04  1.92383814e-04  8.18088312e-05
  2.77834702e-02  1.12243313e-01 -1.26686099e-02  2.19071929e-02
  1.22108470e-03  1.62224294e-02  2.05164881e-02  5.65378210e-03
  4.06231930e-03  1.34338174e-03]

8.递归特征消除

递归特征消除的主要思想是反复的构建模型(如SVM或者回归模型)然后选出最好的(或者最差的)的特征(可以根据系数来选),把选出来的特征放到一遍,然后在剩余的特征上重复这个过程,直到所有特征都遍历了。这个过程中特征被消除的次序就是特征的排序。因此,这是一种寻找最优特征子集的贪心算法。
Sklearn提供了RFE包,可以用于特征消除,还提供了RFECV,可以通过交叉验证来对的特征进行排序。这里 封装sklearn中的RFECV,将得分排名反转,得到评分。
fs.rfecv()
[13  9  5  2 10 13 13 13 12  3 13 13 13 13  0 13  8  6  4  1 11 13 13  7
 13 13 13 13 13 13]

9.全部指标计算和综合评价

# 计算以上全部指标,并完成归一化之后,按照分配的权重计算综合得分(score),并按照得分进行排序
fs.feature_eval(eval_weight=[0.1, 0.1, 0.1, 0.1, 0.1, 0.2, 0.2, 0.2, 0.2]) 
	corr		mic      	ks      	iv			l1			learn		bourta		important	rfecv		score
22	-0.782914	0.474132	0.827374	4.584994	-0.018573	0.976980	0.009898	0.244748	13.0	100.000000
20	-0.776454	0.453242	0.797302	4.448380	-0.000000	0.970666	0.034960	0.705483	11.0	94.078947
0	-0.730029	0.365405	0.723905	3.783957	-0.000000	0.940656	0.024852	0.666401	13.0	88.815789
27	-0.793566	0.436879	0.802904	4.375571	-0.000000	0.968088	0.006664	0.126736	13.0	86.842105
13	-0.548236	0.340502	0.707085	3.651520	-0.000056	0.928352	0.032520	0.120580	13.0	81.907895
26	-0.659610	0.317450	0.700584	2.571675	-0.000000	0.920236	0.023289	0.435703	13.0	81.578947
7	-0.776614	0.439923	0.819856	3.974556	-0.000000	0.963372	0.003340	0.065557	13.0	80.921053
6	-0.696360	0.373305	0.759711	3.008309	-0.000000	0.936799	0.008183	0.156323	13.0	78.947368
2	-0.742636	0.401514	0.744675	3.820877	-0.000000	0.949938	-0.021761	0.360579	5.0		78.618421
23	-0.733825	0.464017	0.804820	4.394695	0.000316	0.970575	0.021532	0.016770	7.0		77.302632
21	-0.456903	0.117602	0.443185	1.542566	-0.009721	0.783139	0.118309	0.379881	13.0	75.657895
25	-0.590998	0.226403	0.549205	2.197353	-0.000000	0.861946	0.018325	0.350023	13.0	71.381579
5	-0.596534	0.212811	0.571759	2.102986	-0.000000	0.866541	0.005434	0.111372	13.0	64.802632
12	-0.556141	0.276573	0.586795	2.803190	-0.000000	0.876242	0.001964	0.066541	13.0	63.157895
3	-0.708984	0.358486	0.731423	3.822343	0.000289	0.941474	0.001050	0.010554	2.0		54.934211
10	-0.567134	0.246681	0.601831	2.534346	-0.000000	0.868413	-0.000403	0.027388	13.0	52.960526
28	-0.416294	0.089774	0.338698	1.633213	-0.000000	0.736239	0.004665	0.102531	13.0	51.644737
1	-0.415185	0.090539	0.452487	1.582487	-0.000000	0.776908	0.002043	0.303336	9.0		48.190789
24	-0.421465	0.097283	0.406361	1.489784	-0.000000	0.757071	0.001480	0.042062	13.0	45.723684
16	-0.253730	0.116072	0.480775	1.612948	-0.000000	0.781546	0.001675	0.033711	8.0		39.473684
15	-0.292999	0.073890	0.377306	1.399908	-0.000000	0.726313	0.001138	0.024305	13.0	36.184211
11	0.008303	0.000000	0.086267	1.068474	-0.000000	0.461609	-0.002358	0.246608	13.0	36.184211
29	-0.323872	0.068337	0.295373	1.338361	-0.000000	0.687911	0.001587	0.033173	13.0	35.526316
17	-0.408042	0.128856	0.452487	1.590341	-0.000000	0.794611	0.000476	0.008601	6.0		32.401316
8	-0.330499	0.065021	0.303142	1.312762	-0.000000	0.700280	0.000441	0.031893	12.0	26.315789
4	-0.358560	0.078689	0.315377	1.346958	-0.000000	0.724408	0.000347	0.022946	10.0	24.671053
19	-0.077972	0.039776	0.204389	1.146121	-0.000000	0.619818	0.000093	0.002230	1.0		5.592105
9	0.012838	0.008280	0.056577	1.153098	-0.000000	0.464124	-0.000292	0.006238	3.0		4.934211
18	0.006522	0.015024	0.005734	1.066727	-0.000000	0.465287	0.000227	0.007753	4.0		4.605263
14	0.067016	0.014678	0.024338	1.063483	-0.000000	0.531610	0.000052	0.002115	0.0		0.000000

三、特征选择方法

以上各种指标为特征选择提供参考,下面提供特征选择的方法,可以直接获得较为优化的特征组合

1.前向搜索

从第一个特征开始选取最优的特征放入特征组合列表中,然后组合第一个选取的特征和其他特征,同样选择评分最佳的组合,将这两个放入特征组合列表中,以此类推,直至数量满足要求。

sf = fs. search_forward(max_feature = 10) #设定向前搜索的最大特征数量,
0 select [22],  	the score :0.976979653545736
1 select [22, 21],  	the score :0.9868864998778198
2 select [22, 21, 26],  	the score :0.9897221832285703
3 select [22, 21, 26, 13],  	the score :0.9915044314118994
4 select [22, 21, 26, 13, 0],  	the score :0.992541012656473
5 select [22, 21, 26, 13, 0, 12],  	the score :0.993202973222626
6 select [22, 21, 26, 13, 0, 12, 29],  	the score :0.9932691107887637
7 select [22, 21, 26, 13, 0, 12, 29, 20],  	the score :0.9935280286369379
8 select [22, 21, 26, 13, 0, 12, 29, 20, 4],  	the score :0.9934640790479309
9 select [22, 21, 26, 13, 0, 12, 29, 20, 4, 24],  	the score :0.9937947668786189

在这里插入图片描述

2.遗传算法启发式

通过启发式算法,在所有特征组合空间,寻找最优特征组合,实现模型评分最大值。时间消耗很大,且具有随机性,可以通过设定初始族群完成

# 使用遗传算法进行特征选择,迭代100次,最大特征限制为10
ga = fs.selcet_by_GA(it_num=100,max_feature=10,mutation=0.4)  # 
0/100,	当前分数:0.9920092042348839
1/100,	当前分数:0.9920092042348839
2/100,	当前分数:0.9920092042348839
3/100,	当前分数:0.9920092042348839
4/100,	当前分数:0.9920278778614842
5/100,	当前分数:0.9930635275910416
6/100,	当前分数:0.9930635275910416
7/100,	当前分数:0.9930635275910416
8/100,	当前分数:0.9930635275910416
9/100,	当前分数:0.9930635275910416
10/100,	当前分数:0.9930635275910416
11/100,	当前分数:0.9930635275910416
12/100,	当前分数:0.9930635275910416
13/100,	当前分数:0.9930635275910416

在这里插入图片描述

# 遗传算法最优的特征组合 
ga[1]
[0, 2, 13, 15, 17, 19, 21, 23, 24, 26]	

遗传算法解0.9944533479949463 ,大于前向搜索

3.最优特征检测

使用其他特征以此替换特征组合中的特征,如发现更优解则进行替换,如没有则保留,返回结果

fs.test_best([0, 2, 13, 15, 17, 19, 21, 23, 24, 26])
loc0 is done 
loc1 is done 
loc2 is done 
the col 15 ,	loc3 is replaceed by 6
loc3 is done 
the col 17 ,	loc4 is replaceed by 15
the col 17 ,	loc4 is replaceed by 28
loc4 is done 
loc5 is done 
loc6 is done 
loc7 is done 
loc8 is done 
loc9 is done 
([0, 2, 13, 6, 28, 19, 21, 23, 24, 26], 0.9945843666651069)

通过最优组合检验之后 发现更优解评分为0.9945 大于之前遗传算法找到的最优解

四、特征选择封装代码

import  pandas as pd
import  numpy as np
from sklearn.model_selection import cross_val_score

class Feature_select:
    def __init__(self, X, y,model,scoring='roc_auc'):
        '''
        X:np.array,features
        y:np.array,label
        '''
        self.X = X
        self.y = y
        self.model = model
        self.scoring = scoring
    def corr(self):
        '''
        关系数计算:输出每一个特征对应的相关系数
        '''
        corr_ = pd.DataFrame(np.hstack([self.X, self.y.reshape(-1, 1)])).corr().iloc[:-1, -1]
        corr_ = np.array(corr_)
        return corr_

    def mic(self):
        '''
        mic系数计算:输出每一个特征对应的mic值
        '''
        from sklearn.feature_selection import mutual_info_classif as mic
        mic_ = mic(self.X, self.y)
        return mic_

    def ks_iv(self):
        '''
        ks和iv计算函数
        '''
        iv_, ks_ = [], []
        for i in range(self.X.shape[1]):
            cuted = pd.qcut(self.X[:, i], q=10, labels=False)
            num_table = pd.crosstab(cuted, self.y)
            good_sum = num_table.sum()[0]
            bad_sum = num_table.sum()[1]
            iv = (((num_table.iloc[:, 1] + 0.5) / bad_sum) - ((num_table.iloc[:, 0] + 0.5) / good_sum) * np.log(
                ((num_table.iloc[:, 1] + 0.5) / bad_sum) / ((num_table.iloc[:, 0] + 0.5) / good_sum))).sum()
            iv_.append(iv)
            ks = max((num_table.iloc[:, 1] / bad_sum).cumsum() - (num_table.iloc[:, 0] / good_sum).cumsum())
            ks_.append(ks)
        return np.array(ks_), np.array(iv_)

    def l1_select(self, alpha=0.15):
        '''
        L1正则化 返回为0的为被剔除变量
        alpha:惩罚系数大小
        '''
        from sklearn.linear_model import Lasso
        lasso = Lasso(alpha=alpha)  # alpha 系数越大 选出的0就越多
        lasso.fit(self.X, self.y)
        return lasso.coef_

    def learn(self):
        '''
        单个特征进入模型时候的五折交叉验证评价指标
        model:评价模型
        scoring:评价指标
        (每个特征需运行一次模型,时间较长)
        '''
        scores = []
        for i in range(self.X.shape[1]):
            score = cross_val_score(self.model, self.X[:, i].reshape(-1, 1), self.y, scoring=self.scoring, cv=5)
            scores.append(np.mean(score))
        return np.array(scores)

    def select_from_model(self):
        '''
        sklean 中select_from_model
        model:训练模型
            针对部分树模型:返回其特征重要度,
            针对线性模型:返回其系数绝对值
        '''
        from sklearn.feature_selection import SelectFromModel
        s_model = SelectFromModel(self.model).fit(self.X, self.y)
        try:
            important_ = s_model.estimator_.feature_importances_
        except:
            important_ = abs(s_model.estimator_.coef_[0])
        return important_

    def boruta(self, it_num=40):
        '''
        参照Boruta思想,通过打乱之前特征的数值,构建shadow特征,比较原始特征和shadow特征的重要程度,评价特征的有效性
        :param it_num: int,迭代次数
        :return: 特征的Boruta得分
        '''
        diff_record = []
        for i in range(it_num):
            X_shadow = self.X.copy()
            np.random.shuffle(X_shadow)
            X_boruta = np.hstack([self.X, X_shadow])
            import_ = Feature_select(X_boruta, self.y, self.model).select_from_model()
            import_ = import_.reshape((2, -1))
            diff_ = import_[0, :] - import_[1, :]
            diff_record.append(diff_)
        bouruta_score = pd.DataFrame(np.array(diff_record).T).mean(1)
        return np.array(bouruta_score)

    def rfecv(self):
        '''
        封装sklearn中的RFECV,将得分排名反转,得到评分
        :return:
        '''
        from sklearn.feature_selection import RFECV
        w = RFECV(self.model, scoring=self.scoring).fit(self.X, self.y)
        return w.ranking_.max() - w.ranking_

    def search_forward(self, max_feature):
        '''
        从第一个特征开始选取最优的特征放入特征组合列表中,然后组合第一个选取的特征和其他特征,同样选择评分最佳的组合,将这两个放入特征组合列表中,以此类推,直至数量满足要求。
        model:评价模型
        max_feature:需要的最大特征数量
        scoring:选择评分
        '''
        best_cols = []  # 存储最优的特征组合编号
        best_scores = []  # 存储最优特征组合下的得分
        for i in range(max_feature):
            best_score = 0
            for col in range(self.X.shape[1]):
                if col not in best_cols:
                    col_test = best_cols.copy()
                    col_test += [col]
                    if len(col_test) == 1:
                        score = cross_val_score(self.model, self.X[:, col_test].reshape(-1, 1), self.y, scoring=self.scoring).mean()
                    else:
                        score = cross_val_score(self.model, self.X[:, col_test], self.y, scoring=self.scoring).mean()
                    if score > best_score:
                        best_col = col
                        best_score = score
            best_cols += [best_col]
            best_scores.append(best_score)
            print(f'{i} select {best_cols},  \tthe score :{best_score}')
        return best_cols, best_scores

    def selcet_by_GA(self, num_=50, pop=None, it_num=50, inherit=0.8, mutation=0.2, max_feature=None,
                     want_max=True):
        '''
        使用遗传算法选择特征组合实现模型的评分最大
        model:评价使用的模型
        num_:遗传算法族群数量
        pop:初始族群
        it_num:种群的数量
        inherit:种群进行杂交的概率
        mutation:种群进行变异的概率
        max_feature:最大特征数量
        scoring:模型评分
        want_max:求解最大值
        返回值:传入长度为特征数量的0,1向量
                历史种群达到的最优值
        '''

        def fun_(x):
            '''传入长度为特征数量的0,1向量,转化为bool之后作为特征的索引,提取特征子集,使用特征子集进行选了返回目标函数值'''
            feature_no = [i for i, j in enumerate(x) if j == 1]
            X_ = self.X[:, feature_no]
            score = cross_val_score(self.model, X_, self.y, scoring=self.scoring, cv=5).mean()
            if max_feature is not None:
                if len(feature_no) <= max_feature:
                    val = score
                else:
                    val = score / (len(feature_no) * len(feature_no))
            else:
                val = score
            return val if want_max else -val

        len_ = self.X.shape[1]

        if pop is None:
            if max_feature is not None:
                pop = np.random.choice([0, 1], (num_, len_), p=[1 - max_feature / len_, max_feature / len_])
            else:
                pop = np.random.randint(0, 2, (num_, len_))
        best_f = 0
        list_best_f = []
        for _ in range(it_num):
            scores = [fun_(i) for i in pop]
            best_fit_ = scores[np.argmax(scores)]
            if best_fit_ > best_f:
                best_f = best_fit_
                best_p = pop[np.argmax(scores)]
            list_best_f.append(best_f)
            fitness = scores - min(scores) + 0.01
            idx = np.random.choice(np.arange(num_), size=num_, replace=True,
                                   p=(fitness) / (fitness.sum()))
            pop = np.array(pop)[idx]
            new_pop = []
            for father in pop:
                child = father
                if np.random.rand() < inherit:
                    mother_id = np.random.randint(num_)
                    low_point = np.random.randint(len_)
                    high_point = np.random.randint(low_point + 1, len_ + 1)
                    child[low_point:high_point] = pop[mother_id][low_point:high_point]
                    if np.random.rand() < mutation:
                        mutate_point = np.random.randint(0, len_)
                        child[mutate_point] = 1 - child[mutate_point]
                new_pop.append(child)
            pop = new_pop
            print(f'{_}/{it_num},\t当前分数:{best_f}')
        return best_p, list_best_f

    def feature_eval(self,eval_weight = [0.1,0.1,0.1,0.1,0.1,0.2,0.2,0.2,0.2]):
        '''
        特征综合评价函数
        :param eval_weight:list,计算评分时候各项指标的平价权重,默认为'corr','mic','ks','iv','l1','learn','bourta','important'的权重为 [0.1,0.1,0.1,0.1,0.1,0.2,0.2,0.2]
        :return: table_eval 各项指标数据的明细,和综合得分
        '''
        corr_ = self.corr()
        mic_ = self.mic()
        ks_iv_ = self.ks_iv()
        l1_ = self.l1_select()
        learn_ = self.learn()
        bourta_ = self.boruta()
        important_ = self.select_from_model()
        rfecv_ = self.rfecv()
        table_eval = pd.DataFrame(np.array([corr_,mic_,ks_iv_[0],ks_iv_[1],l1_,learn_,bourta_,important_,rfecv_]).T,columns=['corr','mic','ks','iv','l1','learn','bourta','important','rfecv'])
        eval_ = (table_eval.abs().rank() * np.array(eval_weight) / np.array(eval_weight).sum()).sum(1)
        score = 100*(eval_ - eval_.min())/(eval_.max() - eval_.min())
        table_eval['score'] = score
        return  table_eval.sort_values(by = 'score',ascending=False)

    def check_best(self,feature_no):
        '''
        使用其他特征以此替换特征组合中的特征,如发现更优解则进行替换,如没有则保留,返回结果
        :param feature_no:待检验特征
        :return: 检验之后的特征,最新得分 
        '''
        best_score = cross_val_score(self.model, self.X[:,feature_no], self.y, scoring=self.scoring, cv=5).mean()
        for i,no in enumerate(feature_no):
            feature_no_t = feature_no.copy()
            for j in range(self.X.shape[1]):
                if j not in feature_no:
                    feature_no_t[i] = j
                    score = cross_val_score(self.model, self.X[:,feature_no_t], self.y, scoring=self.scoring, cv=5).mean()
                    if score > best_score:
                        best_score = score
                        feature_no[i]  = j
                        print(f'the col {no} ,\tloc{i} is replaceed by {j}')
            print(f'loc{i} is done ')
        return  feature_no,best_score

你可能感兴趣的:(机器学习鸭,机器学习,python,人工智能,特征工程,特征选择)