标准化，也称去均值和方差按比例缩放

数据集的 标准化 对scikit-learn中实现的大多数机器学习算法来说是 常见的要求 。如果个别特征或多或少看起来不是很像标准正态分布(具有零均值和单位方差)，那么它们的表现力可能会较差。在实际情况中,我们经常忽略特征的分布形状，直接经过去均值来对某个特征进行中心化，再通过除以非常量特征(non-constant features)的标准差进行缩放。

例如，在机器学习算法的目标函数(例如SVM的RBF内核或线性模型的l1和l2正则化)，许多学习算法中目标函数的基础都是假设所有的特征都是零均值并且具有同一阶数上的方差。如果某个特征的方差比其他特征大几个数量级，那么它就会在学习算法中占据主导位置，导致学习器并不能像我们说期望的那样，从其他特征中学习。

函数 [scale]”sklearn.preprocessing.scale”为数组形状的数据集的标准化提供了一个快捷实现:

  1. from sklearn import preprocessing
  2. import numpy as np
  3. X_train = np.array([[ 1., -1.,  2.],
  4.                      [ 2.,  0.,  0.],
  5.                      [ 0.,  1., -1.]])
  6. X_scaled = preprocessing.scale(X_train)
  8. X_scaled
  9. Out[28]: 
  10. array([[ 0.        , -1.22474487,  1.33630621],
  11.        [ 1.22474487,  0.        , -0.26726124],
  12.        [-1.22474487,  1.22474487, -1.06904497]])

经过缩放后的数据具有零均值以及标准方差:

  1. X_scaled.mean(axis=0)
  2. Out[29]: array([0., 0., 0.])
  4. X_scaled.std(axis=0)
  5. Out[30]: array([1., 1., 1.])

预处理 模块还提供了一个实用类 StandardScaler ，它实现了转化器的API来计算训练集上的平均值和标准偏差，以便以后能够在测试集上重新应用相同的变换。因此，这个类适用于 sklearn.pipeline.Pipeline 的早期步骤:

  1. from sklearn.preprocessing import StandardScaler
  2. scaler = preprocessing.StandardScaler().fit(X_train)
  3. scaler
  4. Out[31]: StandardScaler(copy=True, with_mean=True, with_std=True)
  6. scaler.mean_
  7. Out[32]: array([1.        , 0.        , 0.33333333])
  9. scaler.scale_
  10. Out[33]: array([0.81649658, 0.81649658, 1.24721913])
  12. scaler.transform(X_train)
  13. Out[34]: 
  14. array([[ 0.        , -1.22474487,  1.33630621],
  15.        [ 1.22474487,  0.        , -0.26726124],
  16.        [-1.22474487,  1.22474487, -1.06904497]])

缩放类对象可以在新的数据上实现和训练集相同缩放操作:

  1.  X_test = [[-1., 1., 0.]]
  2. scaler.transform(X_test)                
  3. array([[-2.44...,  1.22..., -0.26...]])

你也可以通过在构造函数 :class:StandardScaler 中传入参数 with_mean=False` 或者``with_std=False 来取消中心化或缩放操作

将特征缩放至特定范围内

一种标准化是将特征缩放到给定的最小值和最大值之间，通常在零和一之间，或者也可以将每个特征的最大绝对值转换至单位大小。可以分别使用 [MinMaxScaler] 和 [MaxAbsScaler] 实现。使用这种缩放的目的包括实现特征极小方差的鲁棒性以及在稀疏矩阵中保留零元素。以下是一个将简单的数据矩阵缩放到[0, 1]的例子:

  1. X_train = np.array([[ 1., -1.,  2.],
  2. ...                     [ 2.,  0.,  0.],
  3. ...                     [ 0.,  1., -1.]])
  4. ...
  5. >>> min_max_scaler = preprocessing.MinMaxScaler()
  6. >>> X_train_minmax = min_max_scaler.fit_transform(X_train)
  7. >>> X_train_minmax
  8. array([[ 0.5       ,  0\.        ,  1\.        ],
  9.  [ 1\.        ,  0.5       ,  0.33333333],
  10.  [ 0\.        ,  1\.        ,  0\.        ]])

同样的转换实例可以被用与在训练过程中不可见的测试数据:实现和训练数据一致的缩放和移位操作:

  1. X_test = np.array([[ -3., -1.,  4.]])
  2. >>> X_test_minmax = min_max_scaler.transform(X_test)
  3. >>> X_test_minmax
  4. array([[-1.5       ,  0\.        ,  1.66666667]])

可以检查缩放器（scaler）属性，来观察在训练集中学习到的转换操作的基本性质:

  1. min_max_scaler.scale_                             
  2. array([ 0.5       ,  0.5       ,  0.33...])
  4. >>> min_max_scaler.min_                               
  5. array([ 0\.        ,  0.5       ,  0.33...])

如果给 MinMaxScaler 提供一个明确的 feature_range=(min, max) ，完整的公式是:

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min

类 MaxAbsScaler 的工作原理非常相似，但是它只通过除以每个特征的最大值将训练数据特征缩放至 [-1, 1] 范围内，这就意味着，训练数据应该是已经零中心化或者是稀疏数据。 例子::用先前例子的数据实现最大绝对值缩放操作。

以下是使用上例中数据运用这个缩放器的例子:

  1. X_train = np.array([[ 1., -1.,  2.],
  2. ...                     [ 2.,  0.,  0.],
  3. ...                     [ 0.,  1., -1.]])
  4. ...
  5. >>> max_abs_scaler = preprocessing.MaxAbsScaler()
  6. >>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
  7. >>> X_train_maxabs                # doctest +NORMALIZE_WHITESPACE^
  8. array([[ 0.5, -1\. ,  1\. ],
  9.  [ 1\. ,  0\. ,  0\. ],
  10.  [ 0\. ,  1\. , -0.5]])
  11. >>> X_test = np.array([[ -3., -1.,  4.]])
  12. >>> X_test_maxabs = max_abs_scaler.transform(X_test)
  13. >>> X_test_maxabs                 
  14. array([[-1.5, -1\. ,  2\. ]])
  15. >>> max_abs_scaler.scale_         
  16. array([ 2.,  1.,  2.])

在 [scale]模块中进一步提供了方便的功能。当你不想创建对象时，可以使用如 [minmax_scale]以及 [maxabs_scale].