常用的数据预处理方法

以下是基于Python_sklearn来实现的：

No1.标准化（Standardization or Mean Removal and Variance Scaling）
变换后各维特征有0均值，单位方差。也叫z-score规范化（零均值规范化）。计算方式是将特征值减去均值，除以标准差。

>>> from sklearn import preprocessing 
>>> X=[[1.,-1.,2.],
       [2.,0.,0.],
       [0.,1.,-1.]]
>>> X_scaled = preprocessing.scale(X)
>>> X_scaled
array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])     

scale处理之后为零均值和单位方差：

>>> X_scaled.mean(axis=0)
array([ 0.,  0.,  0.])
>>> X_scaled.std(axis=0)
array([ 1.,  1.,  1.])  

同样我们也可以通过preprocessing模块提供的StandardScaler 工具类来实现这个功能：

>>> scaler = preprocessing.StandardScaler().fit(X)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)
>>> scaler.mean_
array([ 1.        ,  0.        ,  0.33333333])
>>> scaler.std_
array([ 0.81649658,  0.81649658,  1.24721913])
>>> scaler.transform(X)
array([[ 0.        , -1.22474487,  1.33630621],
       [ 1.22474487,  0.        , -0.26726124],
       [-1.22474487,  1.22474487, -1.06904497]])

简单来说，我们一般会把train和test集放在一起做标准化，或者在train集上做标准化后，用同样的标准化器去标准化test集，此时可以用scaler :

>>> scaler = sklearn.preprocessing.StandardScaler().fit(train)
>>> scaler.transform(train)
>>> scaler.transform(test)

No2.最小-最大规范化（Scaling features to a range）
最小-最大规范化对原始数据进行线性变换，变换到[0,1]区间（也可以是其他固定最小最大值的区间）。通过MinMaxScaler or MaxAbsScaler来实现。

>>> X_train = np.array([[ 1., -1.,  2.],
...                     [ 2.,  0.,  0.],
...                     [ 0.,  1., -1.]])
...
>>> min_max_scaler = preprocessing.MinMaxScaler()
>>> X_train_minmax = min_max_scaler.fit_transform(X_train)
>>> X_train_minmax
array([[ 0.5       ,  0.        ,  1.        ],
       [ 1.        ,  0.5       ,  0.33333333],
       [ 0.        ,  1.        ,  0.        ]])

简单来说：

>>> min_max_scaler = sklearn.preprocessing.MinMaxScaler()
>>> min_max_scaler.fit_transform(X_train)

No3.Scaling data with outliers
当特征中含异常值时：

>>> sklearn.preprocessing.robust_scale

Scaling sparse data

No4.规范化（Normalization）
规范化是将不同变化范围的值映射到相同的固定范围，常见的是[0,1]，此时也称为归一化。Normalize 有L1和L2两个标准。

>>> X = [[ 1., -1., 2.],
     [ 2., 0., 0.],
     [ 0., 1., -1.]]
>>> X_normalized = preprocessing.normalize(X, norm='l2')
>>> X_normalized
array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
>>> normalizer = preprocessing.Normalizer().fit(X) # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')
>>> normalizer.transform(X)
array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])
>>> normalizer.transform([[-1., 1., 0.]])
array([[-0.70710678,  0.70710678,  0.        ]])

简单来说，将每个样本变换成unit norm:

>>> X = [[ 1, -1, 2],[ 2, 0, 0], [ 0, 1, -1]]
>>> sklearn.preprocessing.normalize(X, norm='l2')

得到：

array([[ 0.40, -0.40, 0.81], [ 1, 0, 0], [ 0, 0.70, -0.70]])

可以发现对于每一个样本都有，0.4^2+0.4^2+0.81^2=1,这就是L2 norm，变换后每个样本的各维特征的平方和为1。类似地，L1 norm则是变换后每个样本的各维特征的绝对值和为1。还有max norm，则是将每个样本的各维特征除以该样本各维特征的最大值。
在度量样本之间相似性时，如果使用的是二次型kernel，需要做Normalization。而且，normalize and Normalizer接受scipy密集的数组类和稀疏矩阵。

No5.特征二值化（Binarization）
特征二值化阈值的过程即将数值型数据转化为布尔型的二值数据，可以设置一个阈值（threshold）。即给定阈值，将特征转换为0/1。

>>> X = [[ 1., -1., 2.],
     [ 2., 0., 0.],
     [ 0., 1., -1.]]
>>> binarizer = preprocessing.Binarizer().fit(X) # fit does nothing
>>> binarizer
Binarizer(copy=True, threshold=0.0) # 默认阈值为0.0
>>> binarizer.transform(X)
array([[ 1.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  1.,  0.]])
>>> binarizer = preprocessing.Binarizer(threshold=1.1) # 设定阈值为1.1
>>> binarizer.transform(X)
array([[ 0.,  0.,  1.],
       [ 1.,  0.,  0.],
       [ 0.,  0.,  0.]])

简单来说：

>>> binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)

normalize and Normalizer接受scipy密集的数组类和稀疏矩阵。

No6.类别特征编码（Encoding categorical features）
有时候特征是类别型的，而一些算法的输入必须是数值型，此时需要对其编码。

>>> enc = preprocessing.OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])  
OneHotEncoder(categorical_features='all', dtype=<... 'numpy.float64'>,
       handle_unknown='error', n_values='auto', sparse=True)
>>> enc.transform([[0, 1, 3]]).toarray()
array([[ 1.,  0.,  0.,  1.,  0.,  0.,  0.,  0.,  1.]])

简单来说：

>>> enc = preprocessing.OneHotEncoder()
>>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
>>> enc.transform([[0, 1, 3]]).toarray()  #array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])

其实可以通过从字典加载特征来实现上面的思想：

>>>measurements = [
    {'city': 'Dubai', 'temperature': 33.},
    {'city': 'London', 'temperature': 12.},
    {'city': 'San Fransisco', 'temperature': 18.},
    ]
>>> from sklearn.feature_extraction import DictVectorizer
array([[  1.,   0.,   0.,  33.],       [  0.,   1.,   0.,  12.],       [  0.,   0.,   1.,  18.]])
>>> vec.get_feature_names()
['city=Dubai', 'city=London', 'city=San Fransisco', 'temperature']

No7.标签编码（Label encoding）

>>> le = sklearn.preprocessing.LabelEncoder()  
>>> le.fit([1, 2, 2, 6]) 
>>> le.transform([1, 1, 2, 6])  #array([0, 0, 1, 2]) 
>>> #非数值型转化为数值型
>>> le.fit(["paris", "paris", "tokyo", "amsterdam"])
>>> le.transform(["tokyo", "tokyo", "paris"])  #array([2, 2, 1])

No8.标签二值化（Label binarization）
LabelBinarizer通常通过一个多类标签（label）列表，创建一个label指示器矩阵

>>> lb = preprocessing.LabelBinarizer()
>>> lb.fit([1, 2, 6, 4, 2])
LabelBinarizer(neg_label=0, pos_label=1)
>>> lb.classes_
array([1, 2, 4, 6])
>>> lb.transform([1, 6])
array([[1, 0, 0, 0],
       [0, 0, 0, 1]])

LabelBinarizer也支持每个实例数据显示多个标签（label）

>>> lb.fit_transform([(1, 2), (3,)]) #(1,2)实例中就包含两个label
array([[1, 1, 0],
       [0, 0, 1]])
>>> lb.classes_
array([1, 2, 3])

No9.生成多项式特征（Generating polynomial features）
这个其实涉及到特征工程了，多项式特征/交叉特征。

>>> poly = sklearn.preprocessing.PolynomialFeatures(2)
>>> poly.fit_transform(X)

原始特征：
转化后为：

References：
[1]http://scikit-learn.org/stable/modules/preprocessing.html#scaling-sparse-data
[2]http://2hwp.com/2016/02/03/data-preprocessing/