特征工程 - 数据预处理

---

1 数据预处理流程

1. 去除唯一属性:
   *唯一属性通常是添加的一些id属性等，这些属性并不能刻画样本自身的分布规律，简单地删除这些属性即可。
2. 处理缺失值；
3. 属性编码；
4. 数据标准化、正则化；
5. 特征选择；
6. 主成分分析。

2 缺失值处理

2.1 直接使用含有缺失值的特征

某些算法,如决策树算法,就可以直接使用含有缺失值的数据集

2.2 删除含有缺失值的特征

如果特征含有大量的缺失值，而仅仅包含极少量的有效值，则直接删除该特征的方法是最有效的。但是若其中包含了大量的有效值，则直接删除该特征会丢失大量有效的信息，造成对信息的极大浪费。此时可以考虑缺失值补全的方法。

2.3 缺失值补全

2.3.1 均值插补

如果样本属性的距离是可度量的（如身高、体重等），则该属性的缺失值就以该属性有效值的平均值，中位数等来插补缺失的值。如果样本的属性的距离是不可度量的（如性别、国籍等）， 则该属性的缺失值就以该属性有效值的众数（出现频率最高的值）来插补缺失的值。

2.3.2 建模预测

将缺失的属性作为预测目标来预测，此法补全效果较好，但该方法有个根本的缺陷：如果其他属性和缺失属性无关，则预测的结果毫无意义。但是如果预测结果相当准确，则说明这个缺失属性是没必要考虑纳入数据集中的。一般情况介于两者之间时，应用此法效果较好。

2.3.3 高维映射

将属性映射到高维空间，如采用独热编码对属性扩维。高维映射是最精确的做法，它保留了所有的信息，也未增加任何额外的信息。这样做的好处是完整保留了原始数据的全部信息、不用考虑缺失值。但它的缺点也很明显，就是计算量过于庞大。而且高维映射只有在样本量非常大的时候效果才好，否则会因为过于稀疏，效果很差。

3 特征编码

3.1 二元化

scikit-learn提供的Binarizer能将数据二元化，其原型为：

class sklearn.preprocessing.Binarizer(threshold=0.0, copy=True)

参数:

• threshold: —个浮点数，它指定了属性阈值。低于此阈值的属性转换为0,高于此阈值的属性转换为1。
  *对于稀疏矩阵，该参数必须大于等于0。
• copy: —个布尔值，如果为True，则执行原地修改（节省空间，但是修改了原始数据)。

方法:

• fit(X[, y]):不做任何事情，主要用于流水线Pipeline。
• transform(X[, y, copy]):将每一个样本的属性二元化。
• fit_transform(X[, y]):将每一个样本的属性二元化。

示例：

from sklearn.preprocessing import Binarizer 

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
binarizer = Binarizer(threshold=4.5) #设定阈值为4.5
print('二元转化后:\n', binarizer.transform(X))

二元转化后:
 [[0 0 1 0 1]
 [0 0 0 1 1]
 [0 1 1 1 0]
 [1 1 0 0 0]]

3.2 独热编码

scikit-learn提供的OneHotEncoder实现了独热码，其原型为：

class sklearn.preprocessing.OneHotEncoder(n_values='auto', categorical_features='all', dtype=<class 'float'>, sparse=True, handle_unknown='error')

参数:

• n_values:字符串’auto’，或者一个整数，或者一个整数的数组，它指定了每个属性取 值的上界。
  *属性的取值尽量处理为从0开始的整数。
  
  • ’auto’：自动从训练数据中推断属性值取值的上界。
  • —个整数：指定了所有属性取值的上界。
  • —个整数的数组：每个元素依次指定了一个属性取值的上界。
• categorical_features:字符串’all’，或者下标的数组，或者是一个mask，指定哪些属性需要编码独热码。
  
  • ’all’：所有的属性都将编码为独热码。
  • —个下标的数组：指定下标的属性将编码为独热码。
  • —个mask:对应为True的属性将编码为独热码。
• dtype: —个类型，指定了独热码编码的数值类型，默认为np.float。
• sparse :—个布尔值，指定结果是否稀疏。
• handle_unknown: —个字符，如果进行数据转换时，遇到了某个集合类型的属性，但是该属性未列人categorical_features时的情形，可以指定为如下:
  
  • ’error’：拋出异常。
  • ‘ignore’:忽略。 

属性:

• active_features_: —个数组，给出了激活特征。其元素意义为：如果原始数据的某个 属性的某个取值在转换后数据的第/个属性中激活，则/是数组的元素。
  *该属性仅当n_values= ‘auto’时有效。
• feature_indices_ —个数组，其元素的意义为：原始数据的第i个属性对应转换后数据的[feature_indices_[i],feature_indices_[i+1])之间的属性.
• n_values_: 一个数组，存放每个属性取值的种类（一般为训练数据中该属性取值的 最大值加1，这是因为默认每个属性取值从另开始)。

方法:

• fit(X[, y]):训练OneHotEncoder。
• transform(X):对原始数据执行独热码编码，最终结果值由选取active_features_下标
  中的元素组成。
• fit_transform(X[, y]):训练OneHotEncoder，然后对原始数据执行独热码编码。

示例：

from sklearn.preprocessing import OneHotEncoder

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
encoder = OneHotEncoder(sparse=False)#指定结果不稀疏,返回一般矩阵
encoder.fit(X)

OneHotEncoder(categorical_features='all', dtype=<class 'numpy.float64'>,
       handle_unknown='error', n_values='auto', sparse=False)

print('active_features:', encoder.active_features_)
print('\nfeature_indices:', encoder.feature_indices_)
print('\nn_values:', encoder.n_values_)
print('\n独热编码后:\n', encoder.transform(X))

active_features: [ 1  2  4  9 12 13 15 17 22 23 26 29 32 36 37 38 39]

feature_indices: [ 0 10 18 27 33 40]

n_values: [10  8  9  6  7]

独热编码后:
 [[ 1.  0.  0.  0.  1.  0.  0.  0.  0.  1.  0.  1.  0.  0.  0.  1.  0.]
 [ 0.  1.  0.  0.  0.  1.  0.  0.  1.  0.  0.  0.  1.  0.  0.  0.  1.]
 [ 0.  0.  1.  0.  0.  0.  0.  1.  0.  0.  1.  0.  1.  1.  0.  0.  0.]
 [ 0.  0.  0.  1.  0.  0.  1.  0.  1.  0.  0.  1.  0.  0.  1.  0.  0.]]

4 数据标准化,正则化

4.1 MinMaxScaler

scikit-learn提供的MinMaxScaler实现/min-max标准化，其原型为：

class sklearn.preprocessing.MinMaxSca!er(feature_range=(0, 1), copy=True)

参数:

• feature_range: —个元组(min,max),指定了预期变换之后属性的取值范围。
• copy: —个布尔值，如果为True,则执行原地修改（节省空间，但是修改了原始数据)。

属性:

• min_: —个数组，给出了每个属性的原始的最小值的调整值
  

• scale_: 一个数组，给出了每个属性的缩放倍数。

• data_min_: —个数组，给出了每个属性的原始的最小值。
• data_max_: 一个数组，给出了每个属性的原始的最大值。
• data_range: 一个数组，给出了每个属性的原始的范围（最大值减最小值)。

方法:

• fit(X[, y]):计算每个属性的最小值和最大值，从而为后续的转换做准备。
• transform(X): 执行属性的标准化。
• fit_transform(X[, y]): 计算每个属性的最小值和最大值，然后执行属性的标准化。
• inverse_transform(X): 逆标准化，还原成原始数据。
• partial_fit(X[, y]): 批量学习，学习部分数据。

示例：

from sklearn.preprocessing import MinMaxScaler

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
scaler = MinMaxScaler(feature_range=(0,1))#指定缩放到区间[0,1]
scaler.fit(X)
print('min_:', scaler.min_)
print('\nscale_:', scaler.scale_)
print('\ndata_max_:', scaler.data_max_)
print('\ndata_min_:', scaler.data_min_)
print('\ndata_range_:', scaler.data_range_)
print('\n最小最大值标准化后:\n', scaler.transform(X))

min_: [-0.125      -0.4        -1.         -0.66666667 -1.        ]

scale_: [ 0.125       0.2         0.25        0.33333333  0.33333333]

data_max_: [ 9.  7.  8.  5.  6.]

data_min_: [ 1.  2.  4.  2.  3.]

data_range_: [ 8.  5.  4.  3.  3.]

归一化后:
 [[ 0.          0.          0.25        0.          0.66666667]
 [ 0.125       0.2         0.          1.          1.        ]
 [ 0.375       1.          1.          1.          0.        ]
 [ 1.          0.6         0.          0.          0.33333333]]

4.2 MaxAbsScaler

scikit-learn提供的MaxAbsScaler可以将每个属性值除以该属性的绝对值中的最大值，其原型为：

class sklearn.preprocessing.MaxAbsScaler(copy=True)

参数:

• copy: —个布尔值，如果为True，则执行原地修改（节省空间，但是修改了原始数据)。

属性:

• scale_: 一个数组，给出了每个属性的缩放倍数的倒数。
• max_abs_: —个数组，给出了每个属性的绝对值的最大值。
• n_samples_seen_: —个整数，给出了当前已经处理的样本的数量（用于分批训练)。

方法:

• fit(X[, y]):计算每个属性的绝对值的最大值，从而为后续的转换做准备。
• transform(X):执行属性的标准化。
• fit_transform(X[, y]):计算每个属性的绝对值的最大值，然后执行属性的标准化。
• inverse_transform(X):逆标准化，还原成原始数据。
• partial_fit(X[, y]):批量学习，学习部分数据。

示例：

from sklearn.preprocessing import MaxAbsScaler

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
scaler = MaxAbsScaler()#
scaler.fit(X)
print('scale_::', scaler.scale_)
print('\nmax_abs_:', scaler.max_abs_)
print('\nn_samples_seen_:', scaler.n_samples_seen_)
print('\n绝对值最大标准化后:\n', scaler.transform(X))

scale_: [ 9.  7.  8.  5.  6.]

max_abs_: [ 9.  7.  8.  5.  6.]

n_samples_seen_: 4

绝对值最大标准化后:
 [[ 0.11111111  0.28571429  0.625       0.4         0.83333333]
 [ 0.22222222  0.42857143  0.5         1.          1.        ]
 [ 0.44444444  1.          1.          1.          0.5       ]
 [ 1.          0.71428571  0.5         0.4         0.66666667]]

4.3 StandardScaler

scikit-learn提供的StandardScaler实现了 z-score标准化。其原型为：

class sklearn.preprocessing.StandardScaler(copy=Truef with_mean=True, with_std=True)

参数:

• copy: —个布尔值，如果为True，则执行原地修改（节省空间，但是修改了原始数据)
• with_mean:—个布尔值，如果为True，则缩放之前先将数据中心化（即属性值减去该
  属性的均值)。
  *如果元素数据是稀疏矩阵的形式，则不能指定with_mean=True。
• with_std： 一个布尔值，如果为True，则缩放数据到单位方差。

属性:

• scale_: 一个数组，给出了每个属性的缩放倍数的倒数。
• mean_: 一个数组，给出了原始数据的每个属性的均值，
• var_: —个数组，给出了原始数据的每个属性的方差。
• n_samples_seen_: —个整数，给出了当前已经处理的样本的数量（用于分批训练)。

方法:

• fit(X[, y]):计算每个属性的方差和标准差，从而为后续的转换做准备。
• transform(X):执行属性的标准化
• fit_transform(X[, y]):计算每个属性的方差和标准差，然后执行属性的标准化。
• inverse_transform(X):逆标准化，还原成原始数据。
• partial_fit(X[, y]):批量学习，学习部分数据。

示例：

from sklearn.preprocessing import StandardScaler

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
scaler = StandardScaler()#
scaler.fit(X)
print('scale_::', scaler.scale_)
print('\nmean_:', scaler.mean_)
print('\nvar_:', scaler.var_)
print('\nn_samples_seen_:', scaler.n_samples_seen_)
print('\n标准化后:\n', scaler.transform(X))

scale_:: [ 3.082207    1.92028644  1.63935963  1.5         1.11803399]

mean_: [ 4.    4.25  5.25  3.5   4.5 ]

var_: [ 9.5     3.6875  2.6875  2.25    1.25  ]

n_samples_seen_: 4

标准化后:
 [[-0.97332853 -1.1717002  -0.15249857 -1.          0.4472136 ]
 [-0.64888568 -0.65094455 -0.76249285  1.          1.34164079]
 [ 0.          1.43207802  1.67748427  1.         -1.34164079]
 [ 1.62221421  0.39056673 -0.76249285 -1.         -0.4472136 ]]

4.5 数据正则化

正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。

Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。

         p-范数的计算公式：||X||p=(|x1|^p+|x2|^p+...+|xn|^p)^1/p

该方法主要应用于文本分类和聚类中。例如，对于两个TF-IDF向量的l2-norm进行点积，就可以得到这两个向量的余弦相似性。

scikit-learn提供的Normalizer能将数据正则化，其原型为：

class sklearn.preprocessing.Normalizer(norm='12', copy=True)

参数:

• norm: —个字符串，指定正则化方法。可以为如下Q
  
  • l1:采用L1范数正则化。
  • l2:采用L2范数正则化。
  • max:采用L∞范数正则化。
• copy: —个布尔值，如果为True，则执行原地修改（节省空间，但是修改了原始数据)。

方法:

• fit(X[, y]):不做任何事情，主要用于流水线Pipeline。
• transf_(X[, y, copy]):将每一个样本正则化为范数等于单位1。
• fit_transform(X[, y]):将每一个样本正则化为范数等于单位1。

示例：

from sklearn.preprocessing import Normalizer

X = [[1,2,5,2,5],
     [2,3,4,5,6],
     [4,7,8,5,3],
     [9,5,4,2,4]
    ]
normalizer = Normalizer(norm='l2')
normalizer.fit(X)
print('正则化后:\n', normalizer.transform(X))

正则化后:
 [[ 0.13018891  0.26037782  0.65094455  0.26037782  0.65094455]
 [ 0.21081851  0.31622777  0.42163702  0.52704628  0.63245553]
 [ 0.31330418  0.54828231  0.62660836  0.39163022  0.23497813]
 [ 0.75526322  0.41959068  0.33567254  0.16783627  0.33567254]]

5 特征选取

5.1 VarianceThreshold

方差很小的属性，意味着该属性的识别能力很差。极端情况下，方差为0,意味着该属性在所有样本上的值都是一个常数，可以通过scikit-learn提供的VarianceThreshold来剔除它。

原型：

class sklearn.feature_selection.VarianceThreshold(threshold=0.0)

参数:

• threshold: —个浮点数，指定方差的阈值。低于此阈值的属性将被剔除。

属性:

• variances_: 一个数组，成员分别是各属性的方差。

方法:

• fit(X[, y]): 从样本数据中学习方差。
• transform(X): 执行特征选择（即删除低于指定阈值的属性)。
• fit_transform(X[, y]): 从样本数据中学习方差，然后执行特征选择。
• get_support([indices]):如果indices = True，则返回被选出的特征的下标；如果indices = False，返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但是对于被删除的属性值全部用0代替。

示例：

from sklearn.feature_selection import VarianceThreshold

X = [[100,3,4,5],
    [101,4,2,5],
    [100,5,4,6],
    [101,6,3,9]]
selector = VarianceThreshold(threshold=1)#指定方差阈值
selector.fit(X)
print('Variance:', selector.variances_)
print('\n特征选取后:\n', selector.transform(X))
print('\nThe support is', selector.get_support(True))
print('\n特征选取逆操作:\n', selector.inverse_transform(selector.transform(X)))

Variance: [ 0.25    1.25    0.6875  2.6875]

特征选取后:
 [[3 5]
 [4 5]
 [5 6]
 [6 9]]

The support is [1 3]

特征选取逆操作:
 [[0 3 0 5]
 [0 4 0 5]
 [0 5 0 6]
 [0 6 0 9]]

5.2 单变量特征提取

单变量特征提取通过计算每个特征的某个统计指标，然后根据该指标来选取特征。常用的类如下:

• SelectKBest:可以保留在该统计指标上得分最高的灸个特征。
• SelectPercentile:可以保留在该统计指标上得分最高的百分之&的特征。

5.2.1 SelectKBest

原型：

class sklearn.feature_selection.SelectKBest(score_func=<function f_classif>, k=10)

参数:

• score_func:给出统计指标的函数，其参数为数组X和数组y，返回值为(scores,pvalues)。 sklearn提供的常用函数如下: 
  
  • sklearn.feature_selection.f_regression:基于线性回归分析来计算统计指标。适用于回归问题。
  • sklearn.feature_selection.chi2:计算卡方统计量，适用于分类问题。
  • sklearn.feature_selection.f_classif:根据方差分析（Analysis of variance, ANOVA)的原理，依靠F-分布为概率分布的依据，利用平方和与自由度所计算的组间与组内均方估计出F值，适用于分类问题。
• k: 一个整数或者字符串’alV，指定要保留最佳的几个特征。如果为’aU1，则保留所 有的特征。

属性:

• scores_: 一个数组，给出了所有特征的得分。
• pvalues_: —个数组，给出了所有特征得分的p-values。

方法:

• fit(X,y):从样本数据中学习统计指标得分。
• transform(X):执行特征选择。
• fit_transform(X,y):从样本数据中学习统计指标得分，然后执行特征选择。
• get_support([indices]):如果indices=True,则返回被选出的特征的下标；如果indices =False，则返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但是对于被删除的属性值全部用0代替。

示例：

from sklearn.feature_selection import SelectKBest, f_classif

X = [[1,2,3,4,5],
    [5,3,2,4,1],
    [2,2,2,2,2],
    [6,6,6,6,6]]
y = [0,1,0,1]
selector = SelectKBest(score_func=f_classif, k=3)#使用F-分布选择最高的三个特征
selector.fit(X,y)
print('scores are', selector.scores_)
print('\npvalues are', selector.pvalues_)
print('\nselected index is', selector.get_support(True))
print('\n特征选择后:\n', selector.transform(X))

scores are [ 32.           2.77777767   0.52941179   2.           0.        ]

pvalues are [ 0.0298575   0.23750715  0.54250425  0.29289323  1.        ]

selected index is [0 1 3]

特征选择后:
 [[1 2 4]
 [5 3 4]
 [2 2 2]
 [6 6 6]]

5.2.2 SelectPercentile

原型：

class sklearn.feature_selection.SelectPercentile(score_func=<function f_classif>/ percentile=10)

参数:

• score_func:给出统计指标的函数，其参数为数组X和数组y，返回值为(scores,pvalues)。 sklearn提供的常用函数如下: 
  
  • sklearn.feature_selection.f_regression:基于线性回归分析来计算统计指标。适用于回归问题。
  • sklearn.feature_selection.chi2:计算卡方统计量，适用于分类问题。
  • sklearn.feature_selection.f_classif:根据方差分析（Analysis of variance, ANOVA)的原理，依靠F-分布为概率分布的依据，利用平方和与自由度所计算的组间与组内均方估计出F值，适用于分类问题。

• percentile: —个整数，指定要保留最佳的百分之几的特征，如10表示保留最佳的百分之十的特征。
  属性:

• scores_: 一个数组，给出了所有特征的得分。

• pvalues_: —个数组，给出了所有特征得分的p-values。

方法:

• fit(X,y):从样本数据中学习统计指标得分。
• transform(X):执行特征选择。
• fit_transform(X,y):从样本数据中学习统计指标得分，然后执行特征选择。
• get_support([indices]):如果indices=True,则返回被选出的特征的下标；如果indices =False，则返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但是对于被删除的属性值全部用0代替。

示例：

from sklearn.feature_selection import SelectPercentile, f_classif

X = [[1,2,3,4,5],
    [5,3,2,4,1],
    [2,2,2,2,2],
    [6,6,6,6,6]]
y = [0,1,0,1]
selector = SelectPercentile(score_func=f_classif, percentile=75)#使用F-分布选择最高的百分之75的特征
selector.fit(X,y)
print('scores are', selector.scores_)
print('\npvalues are', selector.pvalues_)
print('\nselected index is', selector.get_support(True))
print('\n特征选择后:\n', selector.transform(X))

scores are [ 32.           2.77777767   0.52941179   2.           0.        ]

pvalues are [ 0.0298575   0.23750715  0.54250425  0.29289323  1.        ]

selected index is [0 1 3]

特征选择后:
 [[1 2 4]
 [5 3 4]
 [2 2 2]
 [6 6 6]]

5.3 包裹式特征选取

包裹式特征选择直接把最终将要使用的学习器的性能作为特征子集的评价准则。

• 优点：由于包裹式特征选择方法直接针对特定学习器进行优化，因此通常包裹式特征选择 比过滤式特征选择更好。
• 缺点：由于特征选择过程中需要多次训练学习器，因此计算开销通常比过滤式特征选择要大得多。

5.3.1RFE

scikit-learn提供了RFE类来实现包裹式特征选取。RFE通过外部提供的一个学习器来选择 特征。它要求学习器学习的是特征的权重（如线性模型），其原理如下:

1. 学习器在初始的特征集合以及初始的权重上训练。
2. 学习器学得每个特征的权重，剔除当前权重最小的那个特征，构成新的训练
   集。
3. 再将学习器在新的训练集上训练，直到剩下的特征数量满足条件为止。

原型：

class sklearn.feature_selection.RFE(estimator, n_features_to_select=None, step=1, estimator_params=None, verbose=0)

参数:

• estimator: —个学习器，它必须提供一个.fit方法和一个.coef_属性，其中.coef_属性中 存放的是学习到的各特征的权重系数。通常使用SVM和广义线性模型作为estimator参数。
• n_features_to_select: —个整数或者None,指定要选出几个特征。如果为None,则默认选取一半的特征。
• step: 一个整数或者浮点数，指定每次迭代要剔除权重最小的几个特征。
  
  • 如果大于等于1，则作为整数，指定每次迭代要剔除权重最小的特征的数量。
  • 如果在0.0~1.0之间，则指定每次迭代要剔除权重最小的特征的比例。
• estimator_params: —个字典，用于设定estimator的参数。该参数将被移除，推荐使用estimator ■ set_params()方法直接设定 estimator 的参数。
• verbose: —个整数，控制输出日志。

属性:

• n_features_: —个整数，给出了被选出的特征的数量。
• support_: 一个数组，给出了被选择特征的mask。
• ranking_: 特征排名，被选出特征的排名为1。

方法:

• fit(X,y): 训练RFE模型。
• transform(X): 执行特征选择。
• fit_transform(X,y): 从样本数据中学习RFE模型，然后执行特征选择。
• get_support([indices]): 如果indices=True，则返回被选出的特征的下标；如果indices =False，则返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但 对于被删除的属性值全部用0代替。
• predict(X)/predict_log_proba(X) /predict_proba(X): 将X进行特征选择之后，再使用内部的estimator来预测。
• score(X, y): 将X进行特征选择之后，再使用内部的estimator来评分。

示例：

from sklearn.feature_selection import RFE
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
y = iris.target

estimator = LinearSVC()
selector = RFE(estimator=estimator, n_features_to_select=2)

selector.fit(X,y)
print('N_features:', selector.n_features_)
print('Support:', selector.support_)
print('Ranking:', selector.ranking_)

N_features: 2
Support: [False  True False  True]
Ranking: [3 1 2 1]
#selector.n_features_ 给出了最终赵选出来的特征数量为2。
#selector.support_ 给出了每个特征被挑选出来与否。如第二个与第四个特征对应的mask 为True,则挑选出了第二个特征与第四个特征。
#selector.ranking_ 给出了最终各特征的排名。如第二个与第四个特征对应的rank为1, 则挑选出了第二个特征与第四个特征。

注意：特征提取对于预测性能的提升没有必然的联系。这里可以比较：

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=123456)

X_t = selector.fit_transform(X, y)
X_train_t, X_test_t, y_train_t, y_test_t = train_test_split(X_t, y, test_size=0.4, random_state=123456)

clf = LinearSVC()
clf_t = LinearSVC()

clf.fit(X_train, y_train)
clf_t.fit(X_train_t, y_train_t)

LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)

print('未做特征选择前得分:', clf.score(X_test, y_test))
print('执行特征选择后得分:', clf_t.score(X_test_t, y_test_t))

未做特征选择前得分: 1.0
执行特征选择后得分: 0.983333333333

可以看到：原始数据利用支持向量机预测的准确率高达100%，而经过特征提取之后的数据利用支持向量机预测的准确率为98.333 %。之所以特征提取之后的预测准确率降低， 是因为被剔除的特征中包含了有效的信息。因此拋弃了这部分信息会在一定程度上降低预测准确率。

5.3.2 RFECV

scikit-learn还提供了RFECV类，它是RFE的一个变体，它执行一个交叉验证来寻找最优的剩余特征数量，因此不需要指定保留多少个特征。其原型为：

class sklearn.feature_selection.RFECV(estimator, step=1, cv=None, scoring=None, estimator_params=None, verbose=0)

参数:

• estimator: —个学习器，它必须提供一个.fit方法和一个.coef_属性，其中.coef_属性中存放的是学习到的各特征的权重系数。通常使用SVM和广义线性模型作为estimator参数。
• step: 一个整数或者浮点数，指定每次迭代要剔除权重最小的几个特征。
  
  • 如果大于等于1，则作为整数，指定每次迭代要剔除权重最小的特征的数量。
  • 如果在0.0~1.0之间，则指定每次迭代要剔除权重最小的特征的比例。

• cv: —个整数，或者交叉验证生成器或者一个可迭代对象，它决定了交叉验证策略。

  • 如果为None，则使用默认的3折交叉验证。
  • 如果为整数k，则使用k折交叉验证。
  • 如果为交叉验证生成器，则直接使用该对象。
  • 如果为可迭代对象，则使用该可迭代对象迭代生成训练-测试集合。

• estimator_params: —个字典，用于设定estimator的参数。该参数将被移除，推荐使用estimator ■ set_params()方法直接设定 estimator 的参数。

• scoring: —个字符串或者可调用对象，用于评估底层estimator的预测性能。如果为 None，则使用estimator.score()方法。
• verbose: —个整数，控制输出日志。

属性:

• n_features_: —个整数，给出了被选出的特征的数量。
• support_: 一个数组，给出了被选择特征的mask。
• ranking_: 特征排名，被选出特征的排名为1。
• grid_scores_: —个数组，给出了交叉验证的预测性能得分，其成员为每个特征子集执行交叉验证后的预测得分。

方法:

• fit(X,y): 训练RFE模型。
• transform(X): 执行特征选择。
• fit_transform(X,y): 从样本数据中学习RFE模型，然后执行特征选择。
• get_support([indices]): 如果indices=True，则返回被选出的特征的下标；如果indices =False，则返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但 对于被删除的属性值全部用0代替。
• predict(X)/predict_log_proba(X) /predict_proba(X): 将X进行特征选择之后，再使用内部的estimator来预测。
• score(X, y): 将X进行特征选择之后，再使用内部的estimator来评分。

import numpy as np
from sklearn.feature_selection import RFECV
from sklearn.svm import LinearSVC
from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data
y = iris.target

estimator = LinearSVC()
selector = RFECV(estimator = estimator, cv=3)
selector.fit(X,y)
print('N_feature:', selector.n_features_)
print('Support is', selector.support_)
print('Ranking:', selector.ranking_)
print('Grid Scores:', selector.grid_scores_)

N_feature: 4
Support is [ True  True  True  True]
Ranking: [1 1 1 1]
Grid Scores: [ 0.91421569  0.94689542  0.95383987  0.96691176]

• selector.n_features_ 给出了最终挑选出来的特征数量为4 (即所有的特征都保留了）。
• selector_support_ 给出了每个特征被挑选出来与否。这里所有特征对应的mask都是True, 因此所有的特征都被选中。
• selector.ranking_给出了最终各特征的排名。这里所有的特征对应的rank为1，因此所 有的特征都被选中。
• selector.grid_scores依次给出了单个特征上交叉验证得到的最佳预测准确率。这里 四个特征依次对应的交叉验证最佳预测准确率为0.91421569 0.94689542 0.95383987 0.96691176

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=123456)

X_t = selector.fit_transform(X, y)
X_train_t, X_test_t, y_train_t, y_test_t = train_test_split(X_t, y, test_size=0.4, random_state=123456)

clf = LinearSVC()
clf_t = LinearSVC()

clf.fit(X_train, y_train)
clf_t.fit(X_train_t, y_train_t)

LinearSVC(C=1.0, class_weight=None, dual=True, fit_intercept=True,
     intercept_scaling=1, loss='squared_hinge', max_iter=1000,
     multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,
     verbose=0)

print('未做特征选择前得分:', clf.score(X_test, y_test))
print('执行特征选择后得分:', clf_t.score(X_test_t, y_test_t))

未做特征选择前得分: 1.0
执行特征选择后得分: 1.0

• 特征均选中,故得分相等

5.4 嵌入式特征选取

scikit-learn提供了SelectFromModel来实现嵌人式特征选取。SelectFromModel使用外部提供的estimator来工作。estimator必须有.coef_或者.feature_importances_属性。当某个特征对应 的.coef_或者.feature_importances_于某个阈值时，该特征将被移除。当然也可以不指定阈值， 而使用启发式的方法，如指定均值mean,指定中位数median或者指定这些统计量的一个倍数， 如0.1*mean。

原型：

class sklearn.feature_selection.SelectFromModel(estimator, threshold=None, prefit=False)

参数:

• estimator: —个学习器，它可以是未训练的(prefit=False)，或者是已经训练好的(prefit =True).
• threshold: —个字符串或者浮点数或者None,指定特征重要性的一个阈值。低于此阈值的特征将被剔除。
  
  • 如果为浮点数，则指定阈值的绝对大小。
  • 如果为字符串，可以为如下:
    
    • ’mean’: 阈值为特征重要性的均值。
    • ‘median’: 阈值为特征重要性的中值。
    • 如果是’1.5*mean’，则表示阈值为1.5倍的特征重要性的均值。
  • 如果为None:
    
    • 如果estimator有一个penalty参数，且该参数设置为’l1’，则阈值默认为1e-5;
    • 其他情况下，阈值默认为’mean’。
• prefit: 一个布尔值，指定estimator是否已经训练好了。如果prefit=False，则estimator
  是未训练的。

属性:

• threshold_: 一个浮点数，存储了用于特征选取重要性的阈值。

方法:

• fit(X,y):训练SelectFromModel模型。
• transform(X):执行特征选择。
• fit_transform(X,y):从样本数据中学习SelectFromModel模型，然后执行特征选择。
• get_support([indices]):如果indices=True，则返回被选出的特征的下标；如果indices =False，则返回一个布尔值组成的数组，该数组指示哪些特征被选择。
• inverse_transform(X):根据被选出来的特征还原原始数据（特征选取的逆操作），但 对于被删除的属性值全部用0代替。
• partial_fit(X[, y]):只训练SelectFromModel模型一次。

示例:

import numpy as np
from sklearn.feature_selection import SelectFromModel
from sklearn.svm import LinearSVC
from sklearn.datasets import load_digits

digits = load_digits()
X = digits.data
y = digits.target

estimator = LinearSVC(penalty='l1', dual=False)
selector = SelectFromModel(estimator=estimator, threshold='mean') 
selector.fit(X,y)
selector.transform(X)
print('Threshold:', selector.threshold_)
print('Support is', selector.get_support(indices=True))

Threshold: 0.679835741464
Support is [ 2  3  4  5  6  9 12 14 18 19 20 21 22 25 26 27 30 33 36 38 41 42 43 44 45
 53 54 55 58 61]

• selector.threshold_ 给出了最终用于特征提取的特征重要性的阈值，这里为0.68324811 0816。
• get_support方法给出了被选中的特征的下标，这里特征的总数量为64,所以下标 从0〜63。

estimator的类型：

• 线性且带有L1正则化项的模型。此时estimator学习的模型具有较好的系数解：大量的系数为零。
  
  • 对于回归问题，可以使用linear_model.Lasso类型的estimator。
    
    • 在Lasso中，α参数控制了稀疏性：如果α越小，则稀疏性越小，则被选择的特征越多；如果α越大，则稀疏性越大，则被选择的特征越少。
  • 对于分类问题，可以使用linear_model.LogisticRegression或者svm.LinearSVC类型的 estimator.
    
    • 在SVM和logistic-regression中，参数C控制了稀疏性：如果C越小，稀疏性越大， 则被选择的特征越少；如果C越大，稀疏性越小，则被选择的特征越多。
      *参数的选取应该是以最终预测性能最佳为目的，而不是为了选取最少的特征为目的。
• 基于决策树的模型（在sklearn.tree模块中）和基于森林的模型（在sklearn.ensemble模
  块中)。这些模型能计算特征的重要性并用于特征选取。

给出下面代码来说明α和C参数与稀疏性的关系。通过权重系数中等于零的系数的个 数来表征稀疏性：零的个数越多，稀疏性越大！

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import LinearSVC
from sklearn.datasets import load_digits, load_diabetes
from sklearn.linear_model import Lasso

def test_Lasso(*data):
    X, y = data
    alphas = np.logspace(-2,2)
    zeros = []
    for alpha in alphas:
        regr = Lasso(alpha=alpha)
        regr.fit(X, y)
        #统计0的个数
        num = 0
        for ele in regr.coef_:
            if abs(ele) < 1e-5:
                num += 1
        zeros.append(num)
    #绘图
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot(alphas, zeros)
    ax.set_xlabel(r'$\alpha$')
    ax.set_xscale('log')
    ax.set_ylim(0, X.shape[1]+1)
    ax.set_ylabel('zeros in coef')
    ax.set_title('Sparsity in Lasso')
    plt.show()

def test_LinearSVC(*data):
    X, y = data
    Cs = np.logspace(-2,2)
    zeros = []
    for C in Cs:
        clf = LinearSVC(C=C, penalty='l1', dual=False)
        clf.fit(X, y)
        #统计0的个数
        num = 0
        for row in clf.coef_:
            for ele in row:
                if abs(ele) < 1e-5:
                    num += 1
        zeros.append(num)
    #绘图
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.plot(Cs, zeros)
    ax.set_xlabel('C')
    ax.set_xscale('log')
    ax.set_ylabel('zeros in coef')
    ax.set_title('Sparsity in SVM')
    plt.show()

data1 = load_diabetes()
X1 = data1.data
y1 = data1.target
test_Lasso(X1, y1)

在Lasso中，α参数控制了稀疏性：如果α越小，则稀疏性越小；如果α越大，则稀疏性越大

data2 = load_digits()
X2 = data2.data
y2 = data2.target
test_LinearSVC(X2, y2)

在SVM和logistic-regression中，参数C控制了稀疏性：如果C越小，则稀疏性越大；如果C越大，则稀疏性越小

6 稀疏表示和字典学习

矩阵中每一行对应一个样本，每一列对应一个特征。考虑以下两类情况：

• 矩阵中可能许多列与当前学习任务无关。如果通过特征选择去除这些列，则学习器训练过程仅需要在较小的矩阵上进行。这就是特征选择要解决的问题。
• 矩阵中有大量元素为0,这称为稀疏矩阵。如果数据集具有高度的稀疏性，则该问题很可能是线性可分的。而对于线性支持向量机，能取得更佳的性能。另外稀疏矩阵有很多很高效的存储方法，可以节省存储空间。这就是字典学习要考虑的问题。

字典学习（dictionary learning ):学习一个字典，通过该字典将样本转化为合适的稀疏表示形式。
稀疏编码（sparse coding):获取样本的稀疏表达，不一定需要通过字典。
这两者通常是在同一个优化求解过程中完成的。因此这里不做区分，统称为字典学习。

scikit-learn提供了DictionaryLearning用于字典学习，其原型为：

class sklearn.decomposition.DictionaryLearning(n_components=None, alpha=1, max_iter=1000, tol=1e-08, fit_algorithm='lars', transform_algorithm='omp', transform_n_nonzero_coefs=None, transform_alpha=None, n_jobs=1, code_init=None, dict_init=None, verbose=False, split_sign=False, random_state=None)

参数:

• n_components: —个整数，指定了字典大小fc。
• alpha: —个浮点数，指定了 ^正则化项的系数A，它控制了稀疏性。
• max_iter: —个整数，指定了最大迭代次数。
• tol: —个浮点数，指定了收敛阈值。
• fit_algorithm: —个字符串，指定了求解算法，可以为下列值。
  
  • ’lars’: 使用least angle regression算法来求解。
  • ‘cd’: 使用coordinate descent算法来求解。
• transform_algorithm: —个字符串，指定了数据转换的方法，可以为下列值。
  
  • ’lasso_lars’: 使用Lars算法来求解。
  • ‘lasso_cd’：使用coordinate descent算法来求解。
  • ‘lars’：使用least angle regression算法来求解。
  • ‘omp’: 使用正交匹配的方法来求解。
  • ‘threshold’:通过字典转换后的坐标中，小于transform_alpha的属性值都设成0。
• transform_n_nonzero_coefs: —个整数，指定了解中每一列中非零元素的个数。只用于lars算法和omp算法（omp算法中，可能被transform_alpha参数覆盖），默认为0.1*n_ features。
• transform_alpha: —个浮点数，默认为 1.0。
  
  • 如果算法为lasso_lars或者lasso_cd，则该参数指定了L1正则化项的系数。
  • 如果算法为threshold，则该参数指定了属性为0的阈值。
  • 如果算法为omp，则该参数指定了重构误差的阈值，此时它覆盖了 transform_n_nonzero_coefs 参数。
• split_sign: —个布尔值，指定是否拆分系数特征向量为其正向值和负向值的拼接。
• n_jobs: —个整数，指定并行性。如果为-1，则表示将训练和预测任务派发到所有 CPU 上。
• code_init: —个数组，指定了初始编码，它用于字典学习算法的热启动。
• dict_init: —个数组，指定了初始字典，它用于字典学习算法的热启动。
• verbose: —个整数，控制输出日志。
• random_state: —个整数，或者一个RandomState实例，或者None。
  
  • 如果为整数，则它指定了随机数生成器的种子。
  • 如果为RandomState实例，则指定了随机数生成器。
  • 如果为None，则使用默认的随机数生成器。

属性:

• components_: 一个数组，存放学到的字典。
• errors_: —个数组，存放每一轮迭代的误差。
• n_iter_: —个整数，存放迭代的次数。

方法:

• fit(X,y): 学习字典。
• transform(X): 根据学到的字典进行编码。
• fit_transform(X,y): 学习字典并执行字典编码

示例:

from sklearn.decomposition import DictionaryLearning

X = [[1,2,3,4,5],
    [5,6,7,8,9],
    [9,7,6,4,5],
    [3,4,5,1,2]]

dct = DictionaryLearning(n_components=3)#指定字典大小key = 3
dct.fit(X)
print('componets are\n', dct.components_)
print('\n字典学习后:\n', dct.transform(X))

componets are
 [[-0.1902219  -0.31385455 -0.42223512 -0.54586777 -0.6237442 ]
 [-0.62141395 -0.48658282 -0.41840773 -0.28357661 -0.34871356]
 [-0.40451992 -0.53935989 -0.67419986 -0.13483997 -0.26967994]]

字典学习后:
 [[ -7.38682846   0.           0.        ]
 [-15.77052262   0.           0.        ]
 [  0.         -14.38712586   0.        ]
 [  0.           0.          -7.41619849]]