数据预处理的常用流程：

　　　　1）去除唯一属性

　　　　2）处理缺失值

　　　　3）属性编码

　　　　4）数据标准化、正则化

　　　　5）特征选择

　　　　6）主成分分析

1、去除唯一属性

　　如id属性，是唯一属性，直接去除就好

2、处理缺失值

(1)直接使用含有缺失值的特征

　　如决策树算法就可以直接使用含有缺失值的特征

(2)删除含有缺失值的特征

(3)缺失值补全

1)均值插补

　　若样本属性的距离是可度量的，则该属性的缺失值就以该属性有效值的平均值来插补缺失的值。如果样本的属性的距离是不可度量的，则该属性的缺失值就以该属性有效值的众数来插补缺失的值。

2)用同类均值插补

　　首先将样本进行分类，然后以该类样本中的均值来插补缺失值。

3)建模预测

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

4)高维映射

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

5)多重插补

　　多重插补认为待插补的值是随机的，它的值来自于已观测到的值。具体实践上通常是估计出待插补的值，然后再加上不同的噪声，形成多组可选插补值。根据某种选择依据，选取最合适的插补值。

6)极大似然估计

7)压缩感知及矩阵补全

　　压缩感知通过利用信号本身所具有的稀疏性，从部分观测样本中回复原信号。压缩感知分为感知测量和重构恢复两个阶段。

　　　　感知测量：此阶段对原始信号进行处理以获得稀疏样本表示。常用的手段是傅里叶变换、小波变换、字典学习、稀疏编码等

　　　　重构恢复：此阶段基于稀疏性从少量观测中恢复原信号。这是压缩感知的核心

　　矩阵补全

3、特征编码

(1)特征二元化：将数值型的属性转换成布尔型的属性

(2)独热编码：构建一个映射，将这些非数值属性映射到整数。其采用N位状态寄存器来对N个可能的取值进行编码，每个状态都由独立的寄存器位表示，并且在任意时刻只有其中的一位有效。

4、数据标准化、正则化

(1)数据标准化：将样本的属性缩放到某个指定范围

　　进行数据标准化的原因：一是因为某些算法要求样本数据具有零均值和单位方差。二是样本不同属性具有不同量级时，消除数量级的影响。

　　min-max标准化：标准化之后，样本x的所有属性值都在[0,1]之间

　　z-score标准化：标准化之后，样本集的所有属性的均值都是0，标准差均为1

(2)数据正则化：将样本的某个范数（如L1范数）缩放到单位1。正则化的过程是针对单个样本的，对于每个样本将样本缩放到单位范数。通常如果使用二次型（如点积）或者其他核方法计算两个样本之间的相似性，该方法会很有用。

5、特征选择

(1)过滤式选择：先对数据集进行特征选择，然后再训练学习器。特征选择过程与后续学习器无关。常用方法有Relief（二分类）、Relief-F（多分类）

(2)包裹式选择：直接把最终将要使用的学习器的性能作为特征子集的评价准则。常用方法LVW

(3)嵌入式选择和L1正则化

　　嵌入式特征选择是在学习器训练过程中自动进行了特征选择

6、稀疏表示和字典学习

代码实现：

  1 from sklearn.preprocessing import Binarizer,OneHotEncoder,MinMaxScaler,MaxAbsScaler,StandardScaler,Normalizer
  2 from sklearn.feature_selection import VarianceThreshold,SelectKBest,f_classif,RFE,RFECV,SelectFromModel
  3 from sklearn.svm import LinearSVC
  4 from sklearn.datasets import load_iris
  5 import numpy as np
  6 from sklearn.decomposition import DictionaryLearning
  7 
  8 #Binary
  9 X=[   [1,2,3,4,5],
 10       [5,4,3,2,1],
 11       [3,3,3,3,3],
 12       [1,1,1,1,1]]
 13 
 14 print("before transform:",X)
 15 binarizer=Binarizer(threshold=2.5)
 16 print("after transform:",binarizer.transform(X))
 17 
 18 #OneHotEncoder
 19 X=[   [1,2,3,4,5],
 20       [5,4,3,2,1],
 21       [3,3,3,3,3],
 22       [1,1,1,1,1]]
 23 print("before transform:",X)
 24 encoder=OneHotEncoder(sparse=False)
 25 encoder.fit(X)
 26 print("active_feature_:",encoder.active_features_)
 27 print("feature_indices_:",encoder.feature_indices_)
 28 print("n_values:",encoder.n_values_)
 29 print("after transform:",encoder.transform([[1,2,3,4,5]]))
 30 
 31 #standardization
 32 
 33 #MinMaxScaler
 34 X=[ [1,5,1,2,10],
 35     [2,6,3,2,7],
 36     [3,7,5,6,4],
 37     [4,8,7,8,1]
 38 ]
 39 
 40 print("before transform:",X)
 41 scaler=MinMaxScaler(feature_range=(0,2))
 42 scaler.fit(X)
 43 print("min_is:",scaler.min_)
 44 print("scale_is:",scaler.scale_)
 45 print("data_max_ is:",scaler.data_max_)
 46 print("data_min_ is:",scaler.data_min_)
 47 print("data_range_ is:",scaler.data_range_)
 48 print("after transform:",scaler.transform(X))
 49 
 50 #MaxAbsScaler
 51 X=[
 52       [1,5,1,2,10],
 53       [2,6,3,2,7],
 54       [3,7,5,6,4],
 55       [4,8,7,8,1]
 56 ]
 57 
 58 print("before transform:",X)
 59 scaler=MaxAbsScaler()
 60 scaler.fit(X)
 61 print("scale_is:",scaler.scale_)
 62 print("max_abs_ is:",scaler.max_abs_)
 63 print("after transform:",scaler.transform(X))
 64 
 65 #StandardScaler:z-score
 66 X=[
 67       [1,5,1,2,10],
 68       [2,6,3,2,7],
 69       [3,7,5,6,4],
 70       [4,8,7,8,1]
 71 ]
 72 print("before transfrom:",X)
 73 scaler=StandardScaler()
 74 scaler.fit(X)
 75 print("scale_ is:",scaler.scale_)
 76 print("mean_ is:",scaler.mean_)
 77 print("var_ is:",scaler.var_)
 78 print("after transfrom:",scaler.transform(X))
 79 
 80 #Normalizer
 81 X=[
 82       [1,2,3,4,5],
 83       [5,4,3,2,1],
 84       [1,3,5,2,4],
 85       [2,4,1,3,5]
 86 ]
 87 print("before transform:",X)
 88 normalizer=Normalizer(norm='l2')
 89 print("after transform:",normalizer.transform(X))
 90 
 91 #VarianceThreshold
 92 X=[
 93       [100,1,2,3],
 94       [100,4,5,6],
 95       [100,7,8,9],
 96       [101,11,12,13]
 97 ]
 98 selector=VarianceThreshold(1)
 99 selector.fit(X)
100 print("Variances is %s"%selector.variances_)
101 print("After transform is %s"%selector.transform(X))
102 print("The surport is %s"%selector.get_support(True))
103 print("After reverse transform is %s"%selector.inverse_transform(selector.transform(X)))
104 
105 #SelectKBest
106 X=[   [1,2,3,4,5],
107       [5,4,3,2,1],
108       [3,3,3,3,3],
109       [1,1,1,1,1]]
110 Y=[0,1,0,1]
111 print("before transform:",X)
112 selector=SelectKBest(score_func=f_classif,k=3)
113 selector.fit(X,Y)
114 print("scores_:",selector.scores_)
115 print("pvalues_:",selector.pvalues_)
116 print("selected index:",selector.get_support(True))
117 print("after transform:",selector.transform(X))
118 
119 #RFE
120 iris=load_iris()
121 X=iris.data
122 Y=iris.target
123 estimator=LinearSVC()
124 selector=RFE(estimator=estimator,n_features_to_select=2)
125 print("Before transform,X=",X)
126 selector.fit(X,Y)
127 selector.transform(X)
128 print("After transform,X=",X)
129 print("Ranking %s"%selector.ranking_)
130 
131 #RFECV
132 iris=load_iris()
133 X=iris.data
134 Y=iris.target
135 estimator=LinearSVC()
136 selector=RFECV(estimator=estimator,cv=3)
137 selector.fit(X,Y)
138 print("Grid Scores %s"%selector.grid_scores_)
139 
140 #SelectFromModel
141 iris=load_iris()
142 X=iris.data
143 Y=iris.target
144 estimator=LinearSVC(penalty='l1',dual=False)
145 selector=SelectFromModel(estimator=estimator,threshold='mean')
146 selector.fit(X,Y)
147 selector.transform(X)
148 print("Threshold %s"%selector.threshold_)
149 print("Support is %s"%selector.get_support(indices=True))
150 
151 #DictionaryLearning
152 X=[
153       [1,2,3,4,5],
154       [6,7,8,9,10],
155       [10,9,8,7,6],
156       [5,4,3,2,1]
157 ]
158 print("before transform:",X)
159 dct=DictionaryLearning(n_components=3)
160 dct.fit(X)
161 print("components is :",dct.components_)
162 print("after transform:",dct.transform(X))

View Code