【skLearn 数据预处理和特征工程】特征工程

---

---

skLearn 数据预处理和特征工程：特征工程

特征提取	特征创造	特征选择
从文字、图像、声音等其他非结构化数据中提取信息作为特征。比如说，总淘宝宝贝的名称中提取出产品类别、产品颜色、是否是网红产品等等。	把现有特征进行组合，或者互相计算得到新的特征。比如说，有一列速度特征，一列距离特征，就可以通过两列相除获取新的时间特征。	从所有的特征中，选择出有意义，对模型有帮助的特征，以避免必须将所有的特征导入模型取训练。

其中是否存活是我们的标签。很明显,以判断"是否存活"为目的,票号,登船的舱门,乘客编号明显是无关特征,可以直接删除。姓名,舱位等级,船舱编号,也基本可以判断是相关性比较低的特征。性别,年龄,船上的亲人数量,这些应该是相关性比较高的特征.所以,特征工程的第一步是:理解业务。

当然了,在真正的数据应用领域,比如金融,医疗,电商,我们的数据不可能像泰坦尼克号数据的特征这样少,这样明显,那如果遇见极端情况,我们无法依赖对业务的理解来选择特征,该怎么办呢?我们有四种方法可以用来选择特征:过滤法,嵌入法,包装法,和降维算法。

---

一、Filter过滤法

过滤法通常作用于预处理步骤，特征选择完全独立于任何机器学习算法。它是根据各种统计检验中的分数以及相关性的各项指标来选择特征。

• 全部特征 --> 最佳特征子集 --> 算法 --> 模型评估

• 方差过滤 VarianceThreshold

这是通过特征本身的方差来筛选特征的类比如一个特征本身的方差很小,就表示样本在这个特征上基本没有差异,可能特征中的大多数值都一样,甚至整个特征的取值都相同,那这个特征对于样本区分没有什么作用所以无论接下来的特征工程要做什么,都要优先消除方差为0的特征。 VarianceThreshold有重要参数threshold表示方差的阈值,表示舍弃所有方差小于 threshold的特征,不填默认为0,即删除所有的记录都相同的特征。

# 导包
import numpy as np 
import pandas as pd

# 读取数据集
data = pd.read_csv("G:\Projects\Jupyter notebook\机器学习skLearn\data\digit recognizor.csv")
data.head()
# 提取数据
x = data.iloc[:,1:]
y = data.iloc[:,0]

# 使用方差过滤
from sklearn.feature_selection import VarianceThreshold

selector = VarianceThreshold() # 实例化，默认方差为0 --- 删除特征值相同的列
x_var0 = selector.fit_transform(x) 
print("特征处理前的形状是：\n",x.shape)
print("特征处理后的形状是：\n",x_var0.shape)

特征处理前的形状是：
 (42000, 784)
特征处理后的形状是：
 (42000, 708)

可以看见,我们已经删除了方差为0的特征,但是依然剩下了708多个特征,明显还需要进一步的特征选择。然而,如果我们知道我们需要多少个特征,方差也可以帮助我们将特征选择一步到位。比如说,我们希望留下一半的特征,那可以设定一个让特征总数减半的方差阈值,只要找到特征方差的中位数,再将这个中位数作为参数 threshold的值输入就好了,假设我们只保留一半的特征，只需要对所有特征的方差取中位数，并以此为阈值。

x_fsvar = VarianceThreshold(np.median(x.var().values)).fit_transform(x)
print("特征处理前的形状是：\n",x.shape)
print("特征处理后的形状是：\n",x_fsvar.shape)

特征处理前的形状是：
 (42000, 784)
特征处理后的形状是：
 (42000, 392)

♦ 方差过滤对于模型的影响对比

我们这样做了以后,对模型效果会有怎样的影响呢?在这里,接下来使用KNN和随机森林分别在方差过滤前和方差过滤后运行的效果和运行时间的对比。KNN是K近邻算法中的分类算法,其原理非常简单,是利用每个样本到其他样本点的距离来判断每个样本点的相似度,然后对样本进行分类。KNN必须遍历每个特征和每个样本,因而特征越多,KNN的计算也就会越缓慢。

使用KNN过滤前后对比

#=== [TIME WARNING: 33mins] ===#
%%timeit
cross_val_score(KNN(),x,y,cv=5).mean() 

#=== [TIME WARNING: 3.7 hours] ===#
#python中的魔法命令,可以直接使用‰%timeit来计算运行这个ce11中的代码所需的时间
# 为了计算所需的时间,需要将这个ce11中的代码运行很多次(通常是7次)后求平均值,因此运行‰的时间会
# 远远超过ce11中的代码单独运行的时间
%%timeit
cross_val_score(KNN(),x_fsvar,y,cv=5). mean()

0.966
0.966
0.966
0.966
0.966
0.966
0.966
0.966
17min 3s ± 39.8 s per loop (mean ± std. dev. of 7 runs, 1 loop each)

使用随机森林过滤前后对比

%%timeit # 过滤前
score = cross_val_score(RFC(n_estimators=10,random_state=0),x,y,cv=5).mean()
print(score)
0.9373571428571429
0.9373571428571429
0.9373571428571429
0.9373571428571429
0.9373571428571429
0.9373571428571429
0.9373571428571429
0.9373571428571429
10.7 s ± 151 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit 过滤后
score = cross_val_score(RFC(n_estimators=10,random_state=0),x_fsvar,y,cv=5).mean()
print(score)
0.9390476190476191
0.9390476190476191
0.9390476190476191
0.9390476190476191
0.9390476190476191
0.9390476190476191
0.9390476190476191
0.9390476190476191
9.71 s ± 145 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

首先可以观察到的是,随机森林的准确率略逊于KNN,但运行时间却连KNN的1%都不到,只需要十秒钟左右。其次,方差过滤后,随机森林的准确率也微弱上升,但运行时间也有稍微改进。

为什么随机森林运行如此之快?为什么方差过滤对随机森林没很大的有影响?这是由于两种算法的原理中涉及到的计算量不同。最近邻算法KNN,单棵决策树,支持向量机SVM,神经网络,回归算法,都需要遍历特征或升维来进行运算,所以他们本身的运算量就很大,需要的时间就很长,因此方差过滤这样的特征选择对他们来说就尤为重要。但对于不需要遍历特征的算法,比如随机森林,它随机选取特征进行分枝,本身运算就非常快速,因此特征选择对它来说效果平平。这其实很容易理解,无论过滤法如何降低特征的数量,随机森林也只会选取固定数量的特征来建模;而最近邻算法就不同了,特征越少,距离计算的维度就越少,模型明显会随着特征的减少变得轻量。因此,过滤法的主要对象是:需要遍历特征或升维的算法们,而过滤法的主要目的是:在维持算法表现的前提下,帮助算法们降低计算成本。

思考:过滤法对随机森林无效,却对树模型有效?
从算法原理上来说,传统决策树需要遍历所有特征,计算不纯度后进行分枝,而随机森林却是行计算和分枝,因此随机森林的运算更快,过滤法对随机森林无用,对决策树却有用。
在 sklearn中,决策树和随机森林都是随机选择特征进行分枝,但决策树在建模过程中随机抽取的特征数目却远远超过随机森林当中每棵树随机抽取的特征数目(比如说对于这个780维的数据,随机森林每棵树只会抽取10~20个特征,而决策树可能会抽取300-400个特征),因此,过滤法对随机森林无用,却对决策树有用。
也因此,在 sklearn中,随机森林中的每棵树都比单独的一棵决策树简单得多,高维数据下的随机森林的计算比决策树快很多。

返回顶部

---

♦ 方差过滤影响总结

	阈值小 被过滤的特征比较少	阈值大 被过滤的特征比较多
模型表现	影响不大	可能变好，代表被过滤的特征大部分是噪音 也可能变糟糕，代表被过滤的特征中含有有效特征。
运行时间	可能降低模型的运行时间 基于方差很小的特征有多少 当方差很小的特征不多时 对模型没有太大的影响	一定能够降低模型的运行时间 算法在遍历特征的时候极端越复杂，运行时间下降得越多

在我们的对比当中,我们使用的方差阈值是特征方差的中位数,因此属于阈值比较大,过滤掉的特征比较多的情况。我们可以观察到,无论是KNN还是随机森林,在过滤掉一半特征之后,模型的精确度都上升了。这说明被我们过滤掉的特征在当前随机模式(randomstate=0)下大部分是噪音。那我们就可以保留这个去掉了一半特征的数据,来为之后的特征选择做准备。当然如果过滤之后模型的效果反而变差了,我们就可以认为,被我们过滤掉的特征中有很多都有有效特征,那我们就放弃过滤,使用其他手段来进行特征选择。

返回顶部

---

• 相关性过滤

♦ 卡方过滤

卡方过滤是专门针对离散型标签(即分类问题）的相关性过滤。卡方检验类feature_selection.chi2计算每个非负特征和标签之间的卡方统计量,并依照卡方统计量由高到低为特征排名。再结合 feature_selection.SelectKBest：输入评分标准来选出前K个分数最高的特征,我们可以借此除去最可能独立于标签,与我们分类目的无关的特征。

另外,如果卡方检验检测到某个特征中所有的值都相同,会提示我们使用方差先进行方差过滤并且,刚才我们已经验证过,当我们使用方差过滤筛选掉一半的特征后,模型的表现时提升的。因此在这里,我们使用 threshold=中位数时完成的方差过滤的数据来做卡方检验(如果方差过滤后模型的表现反而降低了,那我们就不会使用方差过滤后的数据，而是使用原数据。

# 导包
import numpy as np 
import pandas as pd

# 读取数据集
data = pd.read_csv("G:\Projects\Jupyter notebook\机器学习skLearn\data\digit recognizor.csv")
data.head()

x = data.iloc[:,1:]
y = data.iloc[:,0]

# 使用方差过滤
from sklearn.feature_selection import VarianceThreshold
x_fsvar = VarianceThreshold(np.median(x.var().values)).fit_transform(x)

from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.model_selection import cross_val_score
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

# 假设需要300个最佳特征
x_fschi = SelectKBest(chi2,k=300).fit_transform(x_fsvar,y)
x_fschi.shape

(42000, 300)

与之前的0.9390476190476191相比，准确率反而下降了，说明利用卡方过滤，选取的300个特征过少，去除了部分有效特征。

cross_val_score(RFC(n_estimators=10,random_state=0),x_fschi,y,cv=5).mean()

0.9344761904761905

可以看出,模型的效果降低了,这说明我们在设定k=300的时候删除了与模型相关且有效的特征,我们的K值设置得太小,要么我们需要调整K值,要么我们必须放弃相关性过滤。当然,如果模型的表现提升,则说明我们的相关性过滤是有效的,是过滤掉了模型的噪音的,这时候我们就保留相关性过滤的结果。

超参数k的选取

# 超参数k的选取
from matplotlib import pyplot as plt

scores = []
for i in range(200,390,10):
    x_fschi = SelectKBest(chi2,k=i).fit_transform(x_fsvar,y)
    once = cross_val_score(RFC(n_estimators=10,random_state=0),x_fschi,y,cv=5).mean()
    scores.append(once)
plt.plot(range(200,390,10),scores)
plt.tick_params(axis='x',color='white')
plt.tick_params(axis='y',color='white')
plt.show()

通过这条曲线,我们可以观察到,随着K值的不断增加,模型的表现不断上升,这说明,K越大越好,数据中所有的特征都是与特征相关的。但是运行这条曲线的时间同样也是非常地长,接下来我们就来介绍一种更好的选择k的方法:看p值选择k.

卡方检验的本质是推测两组数据之间的差异,其检验的原假设是两组数据是相互独立的。卡方检验返回卡方值和P值两个统计量,其中卡方值很难界定有效的范围,而p值,我们一般使用0.01或0.05作为显著性水平,即p值判断的边界,具体我们可以这样来看:

P值	<=0.05或0.01	>0.05或0.01
数据差异	差异不是自然形成的	这些差异是很自然的样本误差
相关性	两组数据是相关的	两组数据是相互独立的
原假设	拒绝原假设，接收备择假设	接收原假设

从特征工程的角度,我们希望选取卡方值很大,p值小于0.05的特征,即和标签是相关联的特征。而调用SelectKBest之前,我们可以直接从chi2实例化后的模型中获得各个特征所对应的卡方值和P值。

chivalue,pvalues_chi = chi2(x_fsvar,y)

可以看到我们的P值全部是0，即全部小于0.05，也就是说当前所有的特征都与标签存在重要关系，所以每去除一个特征，最终的评分都会降低。
在这种情况下,舍弃任何一个特征,都会舍弃对模型有用的信息,而使模型表现下降,因此在我们对计算速度感到满意时,我们不需要使用相关性过滤来过滤我们的数据。如果我们认为运算速度太缓慢,那我们可以酌情删除一些特征,但前提是,我们必须牺牲模型的表现。

一般做法：

# 在这里插入代码片#k取多少?我们想要消除所有p值大于设定值,比如.05或.01的特征:
# 最佳特征数k = 总特征数 - P值大于0.05的特征数
k = chivalue. shape[0]-(pvalues_chi>0.05). sum()
fschi= SelectKBest(chi2,k=填写具体的最佳数).fit_ transform(fsvar,y)
cross_val_score(rfc(n_estimators=1, random_state=0),x_ fschi,y,cv=5).mean()

返回顶部

---

♦ F检验

F检验,又称 ANOVA,方差齐性检验,是用来捕捉每个特征与标签之间的线性关系的过滤方法。它既可以做回归也可以做分类,因此包含 feature_selection.f_ lassif(f检验分类)和 featureselection.regression (F检验回归)两个类。其中F检验分类用于标签是离散型变量的数据,而F检验回归用于标签是连续型变量。

和卡方检验一样,这两个类需要和类 SelectKBest连用,并且我们也可以直接通过输出的统计量来判断设置一个什么样的K。需要注意的是,F检验在数据服从正态分布时效果会非常稳定,因此如果使用F检验过滤数据的话，会先将数据转换成服从正态分布的方式。

F检验的本质是寻找两组数据之间的线性关系,其原假设是数据不存在显著的线性关系。它返回F值和p值两个统计量。和卡方过滤一样,我们希望选取p值小于.05或0.01的特征,这些特征与标签时显著线性相关的,而p值大于0.05或0.01的特征则被我们认为是和标签没有显著线性关系的特征,应该被删除。以F检验的分类为例,我们继续在数字数据集上来进行特征选择:

# F检验
from sklearn.feature_selection import f_classif
F,pvalues_f = f_classif(x_fsvar,y)
print("F值是：",F)
print("p值是：",pvalues_f)

F值是： [ 618.65383492  846.18897012 1115.40617051 1362.3677305  1452.03355369
 1381.09095571 1138.26505266  464.29616121  660.00977785  849.66393412
 1004.7450309  1124.76177588 1200.99190762 1209.29489877 1110.4944286
 ................................................................
 1196.07900013 1308.12260763 1218.37705687  996.41501921  792.59409228
  663.47516843  550.14745143]

p值是： [0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 ...............................................................
 3.26083326e-322 5.24336441e-231 4.04009647e-300 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000
 0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000]

k = F. shape[0]-(pvalues_f>0.05). sum()
k
392

得到的结论和我们用卡方过滤得到的结论一模一样:没有任何特征的p值大于0.01,所有的特征都是和标签相关的,因此我们不需要相关性过滤。

返回顶部

---

• 互信息法

互信息法是用来捕捉每个特征与标签之间的任意关系(包括线性和非线性关系)的过滤方法。和F检验相似,它既可以做回归也可以做分类,并且包含两个类 feature_selection. mutualinfo_classif(互信息分类)和feature_selection. mutualinfo_regression(互信息回归)。这两个类的用法和参数都和F检验一模一样,不过互信息法比F检验更加强大,F检验只能够找出线性关系,而互信息法可以找出任意关系。

互信息法不返回p值或F值类似的统计量,它返回“每个特征与目标之间的互信息量的估计”,这个估计量在[0,1]之间取值,为0则表示两个变量独立,为1则表示两个变量完全相关。以互信息分类为例的代码如下:

# 互信息法
from sklearn.feature_selection import mutual_info_classif as MIC
result = MIC(x_fsvar,y)
k = result.shape[0] - sum(result<=0)
K
392

#x_fsmic= SelectKBest(MIC,k=填写具体的k).fit_transform(fsvar,y)
#cross_val_score(RFC(n_estimators=10,random_state=0),x_fsmic,y,cv=5).mean()

所有特征的互信息量估计都大于0,因此所有特征都与标签相关。
当然了,无论是F检验还是互信息法,大家也都可以使用学习曲线,只是使用统计量的方法会更加高效。当统计量判断已经没有特征可以删除时,无论用学习曲线如何跑,删除特征都只会降低模型的表现。当然了,如果数据量太庞大,模型太复杂,我们还是可以牺牲模型表现来提升模型速度,一切都看具体需求。

过滤法总结

类	说明	超参数的选择
VarianceThreshold	方差过滤,可输入方差阈值,返回方差大于 阈值的新特征矩阵	看具体数据究竟是含有更多噪声 还是更多有效特征一般就使用0或1 来筛选也可以画学习曲线或取中位数 跑模型来帮助确认
SelectKBest	用来选取K个统计量结果最佳的特征,生成 符合统计量要求的新特征矩阵	看配合使用的统计量
chi2	卡方检验,专用于分类算法,捕捉相关性	追求小于P显著性水平的特征
f_classif	F检验分类,只能捕捉线性相关性 要求数据服从正态分布	追求p小于显著性水平的特征
f_regression	F检验回归,只能捕捉线性相关性 要求数据服从正态分布	追求p小于显著性水平的特征
mutual _info_classif	互信息分类,可以捕捉任何相关性 不能用于稀疏矩阵	追求互信息估计大于0的特征
mutual_info_regression	互信息回归,可以捕捉任何相关性 不能用于稀疏矩阵	追求互信息估计大于0的特征

返回顶部

---

二、Embedded嵌入法

嵌入法是一种让算法自己决定使用哪些特征的方法，即特征选择和算法训练同时进行。先使用某些机器学习的算法和模型进行训练，得到各个特征的权值系数，根据权值系数从大到小选择特征。这些权值系数往往代表了特征对于模型的某种贡献或某种重要性。

过滤法中使用的统计量可以使用统计知识和常识来查找范围(如p值应当低于显著性水平0.05),而嵌入法中使用的权值系数却没有这样的范围可找——我们可以说,权值系数为0的特征对模型丝毫没有作用,但当大量特征都对模型有贡献且贡献不一时,我们就很难去界定一个有效的临界值。这种情况下,模型权值系数就是我们的超参数,我们或许需要学习曲线,或者根据模型本身的某些性质去判断这个超参数的最佳值究竟应该是多少。这里,利用随机森林和决策树模型使用嵌入法。

另外,嵌入法引入了算法来挑选特征,并且每次挑选都会使用全部特征,因此其计算速度也会和应用的算法有很大的关系。如果采用计算量很大,计算缓慢的算法嵌入法本身也会非常耗时耗力。并且,在选择完毕之后,还是需要自己来评估模型。

---

• feature_selection. SelectFromModel

 class sklearn.feature_selection. SelectFromModel(estimator,
  threshold=None, prefit=False, norm_order=1，max features=None)

SelectFromModel是一个元变换器,可以与任何在拟合后具有coef_,feature_importances属性或参数中可选惩罚项的评估器一起使用(比如随机森林和树模型就具有属性 feature_importances_,逻辑回归就带有l1和l2惩罚项线性支持向量机也支持l2惩罚项)。

对于有 feature_importances的模型来说,若重要性低于提供的阈值参数,则认为这些特征不重要并被移除。feature_importances的取值范围是[0,1]。如果设置阈值很小,比如0.001,就可以删除那些对标签预测完全没贡献的特征。如果设置得很接近1,可能只有一两个特征能够被留下。

参数	说明
estimator	使用的模型评估器,只要是带 feature_importances_或者coef_属性,或带有l1和l2惩罚项的模型都可以使用
threshold	特征重要性的阈值,重要性低于这个阈值的特征都将被删除
prefit	默认 False,判断是否将实例化后的模型直接传递给构造函数。如果为true,则必须直接调用 fit和 transform,不能使用fit_transform,并且 SelectFromModel不能与 cross_val_score, GridSearchcv和克隆估计器的类似实用程序一起使用。
norm_order	k可输入非零整数,正无穷,负无穷,默认值为1 在评估器的coef属性高于一维的情况下用于过滤低于阈值的系数的向量的范数的阶数。
max_features	在阈值设定下,要选择的最大特征数。要禁用阈值 max并仅根据features选择,请设置 threshold =-np.inf

# 导包
import numpy as np 
import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier as RFC

# 读取数据集
data = pd.read_csv("G:\Projects\Jupyter notebook\机器学习skLearn\data\digit recognizor.csv")
data.head()

x = data.iloc[:,1:]
y = data.iloc[:,0]

# 使用方差过滤
x_fsvar = VarianceThreshold(np.median(x.var().values)).fit_transform(x)

RFC_ = RFC(n_estimators=10,random_state=0) # 实例化随机森林
x_embedded = SelectFromModel(RFC_,threshold=0.005).fit_transform(x,y)
x_embedded.shape

(42000, 47)

返回顶部

---

♦ 绘制学习曲线 — threshold

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score

plt.figure(figsize=(12,7))
RFC_.fit(x, y).feature_importances_
threshold = np.linspace(0, (RFC_.fit(x, y).feature_importances_).max(), 20)
score = []
for i in threshold:
    x_embedded = SelectFromModel(RFC_, threshold=i).fit_transform(x, y)
    once = cross_val_score(RFC_, x_embedded, y, cv=5).mean()
    score.append(once)
plt.plot(threshold,score)
plt.tick_params(axis='x',colors='white')
plt.tick_params(axis='y',colors='white')
plt.show()

从图像上来看,随着阈值越来越高,模型的效果逐渐变差,被删除的特征越来越多,信息损失也逐渐变大。但是在大约0.001之前,模型的效果都可以维持在0.94左右,因此我们可以从中挑选一个数值来验证一下模型的效果。

可以看出,特征个数瞬间缩小到324多,这比我们在方差过滤的时候选择中位数过滤出来的结果392列要小,并且交叉验证分数0.939高于方差过滤后的结果0.9373571428571429,这是由于嵌入法比方差过滤更具体到模型的表现的缘故,换个算法,使用同样的阈值,效果可能就没有这么好了。

返回顶部

---

♦ 细化学习曲线 — threshold

plt.figure(figsize=(20,5))
score1 = []
for i in np.linspace(0,0.00134,20):
    x_embedded = SelectFromModel(RFC_, threshold=i).fit_transform(x, y)
    once1 = cross_val_score(RFC_, x_embedded, y, cv=5).mean()
    score1.append(once1)
plt.plot(np.linspace(0,0.00134,20),score1)
plt.tick_params(axis='x',colors='white')
plt.tick_params(axis='y',colors='white')
plt.xticks(np.linspace(0,0.00134,20))
plt.show()

进一步细化学习曲线：

plt.figure(figsize=(20,5))
score1 = []
for i in np.linspace(0,0.0002,20):
    x_embedded = SelectFromModel(RFC_, threshold=i).fit_transform(x, y)
    once1 = cross_val_score(RFC_, x_embedded, y, cv=5).mean()
    score1.append(once1)
plt.plot(np.linspace(0,0.0002,20),score1)
plt.tick_params(axis='x',colors='white')
plt.tick_params(axis='y',colors='white')
plt.show()

通过进一步的细化学习曲线，大致在0.000117左右的时候达到最大值，进过测试，准确度达到0.941之高。

得出的特征数目虽然大于方差筛选,但是模型的表现也比没有筛选之前更高,已经完全可以和计算一次半小时的KNN相匹敌(KNN的准确率是96.58%),接下来再对随机森林进行调参,准确率应该还可以再升高不少。可见在嵌入法下,我们很容易就能够实现特征选择的目标:减少计算量,提升模型表现。因此,比起要思考很多统计量的过滤法来说,嵌入法可能是更有效的一种方法。然而,过滤法的计算远远比嵌入法要快,所以大型数据中,我们还是会优先考虑过滤法。

返回顶部

---

三、Wrapper包装法

包装法也是一个特征选择和算法训练同时进行的方法,与嵌入法十分相似,它也是依赖于算法自身的选择，比如coef_属性 、feature_importances_属性来完成特征选择。但不同的是,我们往往使用一个目标函数作为黑盒来帮助我们选取特征,而不是自己输入某个评估指标或统计量的阈值。包装法在初始特征集上训练评估器，并且通过coef_属性 、feature_importances_属性获得每个特征的重要性。然后,从当前的一组特征中修剪最不重要的特征。在修剪的集合上递归地重复该过程,直到最终到达所需数量的要选择的特征区别于嵌入法的每次都使用全部特征来进行训练和建模,因此包装法需要的计算成本位于嵌入法和过滤法中间。

注意,在这个图中的“算法”,指的不是我们最终用来导入数据的分类或回归算法(不是随机森林),而是专业的数据挖掘算法,即我们的目标函数。这些数据挖掘算法的核心功能就是选取最佳特征子集。

---

最典型的目标函数是递归特征消除法(Recursive feature elimination,简写为RFE)。它是一种贪婪的优化算法,旨在找到性能最佳的特征子集。它反复创建模型,并在每次迭代时保留最佳特征或剔除最差特征,下一次迭代时,它会使用上一次建模中没有被选中的特征来构建下一个模型,直到所有特征都耗尽为止。然后,它根据自己保留或剔除特征的顺序来对特征进行排名,最终选出一个最佳子集。包装法的效果是所有特征选择方法中最利于提升模型表现的,它可以使用很少的特征达到很优秀的效果。除此之外,在特征数目相同时,包装法和嵌入法的效果能够匹敌,不过它比嵌入法算得更快,虽然它的计算量也十分庞大,不适用于太大型的数据相比之下,包装法是最高效的特征选择方法。

• feature_selection. RFE

class sklearn. feature_selection. RFE (estimator n features_ to_select=None, step=1, verbose=0)

参数 estimator是需要填写的实例化后的评估器,n_ features_to_select是想要选择的特征个数,step表示每次代中希望移除的特征个数。除此之外,RF类有两个很重要的属性, support_:返回所有的特征的是否最后被选中的布尔矩阵,以及 ranking_返回特征的按数次迭代中综合重要性的排名。类 feature_selection. RFECV会在交叉验证循环中执行RFE以找到最佳数量的特征,增加参数cv,其他用法都和RFE一模一样。

# 导包
import numpy as np 
import pandas as pd
from sklearn.feature_selection import RFE
from sklearn.ensemble import RandomForestClassifier as RFC
from sklearn.model_selection import cross_val_score

# 读取数据集
data = pd.read_csv("G:\Projects\Jupyter notebook\机器学习skLearn\data\digit recognizor.csv")
data.head()
# 提取数据集
x = data.iloc[:,1:]
y = data.iloc[:,0]

# 建模
RFC_ = RFC(n_estimators=10,random_state=0)
selector = RFE(RFC_,n_features_to_select=340,step=50).fit(x,y)
print("最后被选中的布尔矩阵:\n",selector.support_.sum())
print("特征综合排名：\n",selector.ranking_)

x_wrapper = selector.transform(x)
score = cross_val_score(RFC_,x_wrapper,y,cv=5).mean()
print("包装法选取特征模型评估：\n",score)

最后被选中的布尔矩阵:
 340
特征综合排名：
 [10  9  8  7  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6  6
  6  6  6  6  6  6  7  7  6  6  5  6  5  6  6  6  6  6  6  6  6  6  6  7
  6  7  7  7  7  7  7  7  7  7  7  7  7  7  7  7  6  6  5  4  4  5  3  4
  4  4  5  4  5  7  6  7  7  7  8  8  8  8  8  8  8  8  6  7  4  3  1  2
  3  3  1  1  1  1  1  3  3  4  5  5  5  8  8  9  9  9  9  8  9  9  4  4
  3  2  1  1  1  1  1  1  1  1  1  1  2  3  3  4  5  5  9  9 10 10 10 10
  7  4  4  3  1  1  1  1  1  1  1  1  1  1  1  1  1  1  2  3  3  5  8 10
 10 10 10  9  4  4  3  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
  3  4 10 10 10 10  9  7  4  3  2  2  1  1  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  2  4  4 10  9 10  6  6  4  2  3  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  3  5  9 10  8  7  4  5  3  2  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  2  1  2  4 10 10 10  9  7  5  3  3  1  1
  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  3  3  5  5  9  9  9  7  5
  5  3  2  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  2  4  5  9  9
  9  9  9  5  4  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
  4  5  7 10 10  9 10  9  4  1  2  1  1  1  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  3  5 10  9 10 10  9  7  4  2  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  2  2  4  8  9 10 10 10  5  4  2  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  2  3  5 10 10 10 10  9  5  4  1  1  1
  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  3  3  4  5  9 10 10 10  5
  3  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  3  3  4  8  8
 10 10  9  5  3  3  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  2  3
  3  4 10 10 10 10  8  4  3  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
  1  1  1  2  4  5  8 10 10 10 10  5  2  1  1  1  1  1  1  1  1  1  1  1
  1  1  1  1  1  1  1  2  4  7 10 10 10 10  8  5  3  2  1  1  1  1  1  1
  1  1  1  1  1  1  1  1  1  2  3  3  5  5  7  9  9  9  9  5  5  2  2  1
  1  1  1  1  1  1  1  1  1  1  1  2  2  2  3  4  5  5  8  9  9  9  9  7
  4  4  2  1  1  1  1  1  1  1  1  1  1  1  1  3  3  3  5  5  9  8  9  9
  9  9  9  5  4  4  2  2  1  1  1  1  1  2  1  1  1  1  2  2  3  4  5  5
  9  8  8  8  8  8  8  7  8  6  4  2  2  1  1  2  2  1  2  2  3  2  2  4
  4  5  5  8  8  8  7  7  7  7  7  7  7  5  5  4  5  4  3  3  3  4  3  3
  4  3  4  5  5  6  7  7  7  6  7  8  8  8  9  9  9  9  6  8  8  8  7  8
  8  8  7  8  8  8  8  8  7  8  8  8  8  9 10  7]
包装法选取特征模型评估：
 0.9379761904761905

♦ 绘制学习曲线 n_features_to_select

score = []
for i in range(1, 751, 50):
    x_wrapper = RFE(RFC_, n_features_to_select=i,step=50).fit_transform(x, y)
    once = cross_val_score(RFC_, x_wrapper, y, cv=5).mean()
    score.append(once)
plt.figure(figsize=(20, 5))
plt.plot(range(1, 751, 50), score)
plt.xticks(range(1, 751, 50))
plt.tick_params(axis='x', colors='white')
plt.tick_params(axis='y', colors='white')
plt.show()

明显能够看出,在包装法下面,应用50个特征时,模型的表现就已经达到了90%以上,比嵌入法和过滤法都高效很多。我们可以放大图像,寻找模型变得非常稳定的点来画进一步的学习曲线(就像我们在嵌入法中做的那样)。如果我们此时追求的是最大化降低模型的运行时间,我们甚至可以直接选择50作为特征的数目,这是一个在缩减了94%的特征的基础上,还能保证模型表现在90%以上的特征组合,不可谓不高效。

返回顶部

---