数据预处理-sklearn.preprocessing

以下介绍的所有方法都源自于sklearn.preprocessing

数据预处理相关理论：http://scikit-learn.sourceforge.net/stable/modules/preprocessing.html#preprocessing
方法大全：http://scikit-learn.sourceforge.net/stable/modules/classes.html#module-sklearn.preprocessing

为什么要标准化（数据预处理）？

For instance, many elements used in the objective function of a learning algorithm (such as the RBF kernel of Support Vector Machines or the l1 and l2 regularizers of linear models) assume that all features are centered around zero and have variance in the same order. 很多算法默认是在均值为0的条件下成立的。

1.标准化 scale

它做了两步，一是去均值的中心化（均值变为0），二是方差的规模化（方差变为1）

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

>>> X_scaled                                          
array([[ 0.  ..., -1.22...,  1.33...],
       [ 1.22...,  0.  ..., -0.26...],
       [-1.22...,  1.22..., -1.06...]])

结果：

>>> X_scaled.mean(axis=0)  #均值变0
array([ 0.,  0.,  0.])

>>> X_scaled.std(axis=0) #方差变1
array([ 1.,  1.,  1.])

加强版 StandardScaler

它可以像sklearn.manifold.TSNE一样，适用于先 fit 再 transform的场景，比如要多次转换训练集和测试集的数据。

>>> scaler = preprocessing.StandardScaler().fit(X)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)

>>> scaler.mean_   # 查看每一列的均值                                    
array([ 1. ...,  0. ...,  0.33...])

>>> scaler.std_    # 查看每一列的标准差（均方差）                                       
array([ 0.81...,  0.81...,  1.24...])

>>> scaler.transform(X)                               
array([[ 0.  ..., -1.22...,  1.33...],
       [ 1.22...,  0.  ..., -0.26...],
       [-1.22...,  1.22..., -1.06...]])

然后，可以对新数据使用scaler实例，以与对训练集使用相同的方式对其进行转换：

>>> scaler.transform([[-1.,  1., 0.]])                
array([[-2.44...,  1.22..., -0.26...]])

确定范围的标准化 MinMaxScaler

另一种标准化是将特性缩放到给定的最小值和最大值之间，通常在0和1之间，我们用 MinMaxScaler。
使用这种标准化的动机包括增加非常小的特征标准差的鲁棒性，以及在稀疏数据中保持零项（数据集的标准差非常非常小，有时数据中有很多很多零（稀疏数据）需要保存住０元素）。

class sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True)
参数feature_range=(0, 1)就是控制标准化的范围，计算原则：

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std / (max - min) + min  #标准化后的结果

Here is an example to scale a toy data matrix to the [0, 1] range:

>>> 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.        ]])

可以通过查看属性来观察转换的操作（scale_+min_），scale是乘，min是加：

>>> min_max_scaler.scale_                             
array([ 0.5       ,  0.5       ,  0.33...])

>>> min_max_scaler.min_                               
array([ 0.        ,  0.5       ,  0.33...])

2 正则化Normalization

正则化的作用是把单一样本缩放到单位范数的特征。如果您计划使用二次形式(如点积或任何其他内核)来量化任意一对样本的相似性，则此过程将非常有用。

normalize函数提供了一种快速简单的方法，可以使用l1或l2范数在单个类数组数据集上执行此操作:

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

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

加强版 Normalizer

同标准化scale，这里也有加强版：

>>> normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing
>>> normalizer
Normalizer(copy=True, norm='l2')

>>> normalizer.transform(X)                            
array([[ 0.40..., -0.40...,  0.81...],
       [ 1.  ...,  0.  ...,  0.  ...],
       [ 0.  ...,  0.70..., -0.70...]])

>>> normalizer.transform([[-1.,  1., 0.]])             
array([[-0.70...,  0.70...,  0.  ...]])

NaN值的处理—Imputation

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]])
Imputer(axis=0, copy=True, missing_values='NaN', strategy='mean', verbose=0)
>>> X = [[np.nan, 2], [6, np.nan], [7, 6]]  #待转化的数据
>>> print(imp.transform(X))                           
[[ 4.          2.        ]
 [ 6.          3.666...]
 [ 7.          6.        ]]

它也支持稀疏矩阵：

>>> 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)
Imputer(axis=0, copy=True, missing_values=0, strategy='mean', verbose=0)
>>> X_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
>>> print(imp.transform(X_test))                      
[[ 4.          2.        ]
 [ 6.          3.666...]
 [ 7.          6.        ]]

LabelEncoder()、OneHotEncoder()请参阅：

https://blog.csdn.net/weixin_42468475/article/details/105511063