Scikit-learn Preprocessing 预处理

本文主要是对照scikit-learn的preprocessing章节结合代码简单的回顾下预处理技术的几种方法，主要包括标准化、数据最大最小缩放处理、正则化、特征二值化和数据缺失值处理。

数学基础

均值公式：

$$\bar{x}=\frac{1}{n} \sum_{i=1}^{n} x_{i}$$

方差公式：

$$s^{2}=\frac{1}{n} \sum_{i=1}^{n}\left(x_{i}-\bar{x}\right)^{2}$$

0-范数，向量中非零元素的个数。

1-范数：

$$\|X\|=\sum_{i=1}^{n}\left|x_{i}\right|$$

2-范数：

$$\|X\|_{2}=\left(\sum_{i=1}^{n} x_{i}^{2}\right)^{\frac{1}{2}}$$

p-范数的计算公式：

$$\|X\|_{p}=\left(|x 1|^{p}+|x 2|^{p}+\ldots+|x n|^{p}\right)^{\frac{1}{p}}$$

1、标准化（Standardization）

实际操做中，常常忽略特征数据的分布形状，移除每一个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。(作几率论的题常常用这招啊)

可是，当单个特征的样本取值相差甚大或明显不听从高斯正态分布时，标准化表现的效果较差。

公式为：(X-X_mean)/X_std 计算时对每一个属性/每列分别进行.

将数据按其属性(按列进行)减去其均值，而后除以其方差。最后获得的结果是，对每一个属性/每列来讲全部数据都汇集在0附近，方差值为1。

方法一：使用sklearn.preprocessing.scale()函数

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
X_mean = X.mean(axis=0)  #calculate mean
X_std = X.std(axis=0)   #calculate variance 
X1 = (X-X_mean)/X_std   #standardize X
X_scale = preprocessing.scale(X)  #use function preprocessing.scale to standardize X

最后X_scale的值和X1的值是同样的

方法2：sklearn.preprocessing.StandardScaler类

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
scaler = preprocessing.StandardScaler()
X_scaled = scaler.fit_transform(X)

这两个方法获得最后的结果都是同样的。

2、放缩（MinMaxScaler）

另外一种经常使用的方法是将属性缩放到一个指定的最大值和最小值(一般是1-0)之间，这能够经过preprocessing.MinMaxScaler类来实现。

使用这种方法的目的包括：

• 一、对于方差很是小的属性能够加强其稳定性；
• 二、维持稀疏矩阵中为0的条目。

下面将数据缩至0-1之间，采用MinMaxScaler函数

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
min_max_scaler = preprocessing.MinMaxScaler()
X_minMax = min_max_scaler.fit_transform(X)
X_minMax

array([[0.5       , 0.        , 1.        ],
       [1.        , 0.5       , 0.33333333],
       [0.        , 1.        , 0.        ]])

3、正则化（Normalization）

正则化的过程是将每一个样本缩放到单位范数(每一个样本的范数为1)，若是要使用如二次型(点积)或者其它核方法计算两个样本之间的类似性这个方法会颇有用。

该方法是文本分类和聚类分析中常用的向量空间模型（Vector Space Model)的基础.

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

方法1：使用sklearn.preprocessing.normalize()函数

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
X_normalized = preprocessing.normalize(X, norm='l2')
X_normalized

方法2：sklearn.preprocessing.StandardScaler类

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
normalizer = preprocessing.Normalizer()
normalizer.transform(X)     

两种方法的结果相同：

array([[ 0.40824829, -0.40824829,  0.81649658],
       [ 1.        ,  0.        ,  0.        ],
       [ 0.        ,  0.70710678, -0.70710678]])

4、二值化（Binarization）

特征的二值化主要是为了将数据特征转变成boolean变量。

from sklearn import preprocessing 
import numpy as np
X = np.array([[ 1., -1.,  2.],
        [ 2.,  0.,  0.],
        [ 0.,  1., -1.]])
binarizer = preprocessing.Binarizer()
binarizer.transform(X)

Binarizer函数也能够设定一个阈值，结果数据值大于阈值的为1，小于阈值的为0，实例代码以下：

//只需加一个参数
binarizer = preprocessing.Binarizer(threshold=1.1)

5、缺失值处理

现实中的数据集都包含有缺失值，要么是空白的，要么使用NaNs或者其它的符号替代。

这些数据没法直接使用scikit-learn分类器直接训练，因此须要进行处理。

幸运地是，sklearn中的Imputer类提供了一些基本的方法来处理缺失值，如使用均值、中位值或者缺失值所在列中频繁出现的值来替换。

import numpy as np
from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN', strategy='mean', axis=0)
imp.fit([[1, 2], [np.nan, 3], [7, 6]])

X = [[np.nan, 2], [6, np.nan], [7, 6]]
print(imp.transform(X))  

Imputer类一样支持稀疏矩阵（即含有大量的0）：

import scipy.sparse as sp
X = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
imp = Imputer(missing_values=0, strategy='mean', axis=0)
imp.fit(X)

X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
print(imp.transform(X_test))  

更多的请到scikit-learn的官方文档中查看

• 英文版本：preprocessing.
• 中文版：预处理数据

 

 

参考连接：https://blog.csdn.net/Dream_angel_Z/article/details/49406573