Sklearn学习笔记（1）——数据预处理

写在开始：Sklearn 预处理

Sklearn 中【数据预处理】

• 工具包：sklearn.preprocessing
• 两大块：特征提取和标准化
• 过程：特征向量 → 特征表达（符合评估器 API的形式）
  ( raw feature vectors → representation that is more suitable for the downstream estimators)

在一般情况下，学习算法受益于数据集的标准化(standardization)。如果数据集集存在某些异常值，那么稳定的放缩( scalers )和转化(transformers )是比较合适的。有需要，可以在Compare the effect of different scalers on data with outliers 进一步关注不同的放缩器、转化器和正规化器(normalizers)的效果差异。

1. 标准化/去均值和方差缩放：均值为0，方差为1

数据集的标准化 对scikit-learn中实现的大多数机器学习算法来说是常见的要求 。如果个别特征或多或少看起来不是很像标准正态分布(具有零均值和单位方差)，那么它们的表现力可能会较差。

在实际情况中,我们经常忽略特征的分布形状，直接经过去均值来对某个特征进行中心化，再通过除以非常量特征(non-constant features)的标准差进行缩放。

• 目的
  将数据进行缩放，使其具有零均值及标准方差。

• 原因：

许多学习算法中目标函数的基础都是假设所有的特征都是零均值并且具有同一阶数上的方差。
如果某个特征的方差比其他特征大几个数量级，那么它就会在学习算法中占据主导位置，导致学习器并不能像我们说期望的那样，从其他特征中学习。

StandardScaler()

• scale()：针对简单数组

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

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

• Transformer()

Transformer()是 位于preprocessing 模块——StandardScaler() 类下面 API，它实现了转化器的API来计算训练集上的平均值和标准偏差，以便以后能够在测试集上重新应用相同的变换。

有需要也可以通过在构造函数 StandardScaler 中传入参数 with_mean=False 或者with_std=False 来取消中心化或缩放操作。

>>> scaler = preprocessing.StandardScaler().fit(X_train)
>>> scaler
StandardScaler()

>>> scaler.mean_
array([1. ..., 0. ..., 0.33...])

>>> scaler.scale_
array([0.81..., 0.81..., 1.24...])

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

补：StandardScaler() 类

• 类

class sklearn.preprocessing.StandardScaler(copy=True, with_mean=True, with_std=True)

若 with_mean=False ，则 u=0
若 with_std=False，则 s = 1

样本 x
均值 u
标准差 ：s = 根号下方差
标准分：z = (x - u) / s

• 类方法
  需要使用 transform() 提取并被存起来的均值和标准差

2. 将特征缩放至特定范围内

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

2.1 MinMaxScaler() ：缩放到0 和 1 之间

例子：将简单的数据矩阵缩放到[0, 1]：

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

如果给 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

2.2 MaxAbsScaler()：将最大绝对值转换至单位大小

缩放稀疏（矩阵）数据：将最大绝对值转换至单位大小

中心化稀疏(矩阵)数据会破坏数据的稀疏结构，因此很少有一个比较明智的实现方式。但是缩放稀疏输入是有意义的，尤其是当几个特征在不同的量级范围时。

如果已经中心化的数据并不是很大，使用 toarray 方法将输入的稀疏矩阵显式转换为数组是另一种选择。

3. 归一化：缩放单个样本至单位范数

归一化 是缩放单个样本以具有单位范数的过程。如果你计划使用二次形式(如点积或任何其他核函数)来量化任何样本间的相似度，则此过程将非常有用。

这个观点基于 向量空间模型(Vector Space Model) ，经常在文本分类和内容聚类中使用。

3.1 normalize ()函数

normalize () 可以在简单数组上实现：

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

3.2 Normalizer()类

>>> normalizer = preprocessing.Normalizer().fit(X)  # fit does nothing
>>> normalizer
Normalizer()

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

注意：Normalizer()的fit()实际不起作用。

4. 类别特征编码

4.1 OrdinalEncoder ()

>>> enc = preprocessing.OrdinalEncoder()
>>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']]
>>> enc.fit(X)  
OrdinalEncoder(categories='auto', dtype=<... 'numpy.float64'>)
>>> enc.transform([['female', 'from US', 'uses Safari']])
array([[0., 1., 1.]])

这样的整数特征表示并不能在scikit-learn的估计器中直接使用，因为这样的连续输入，估计器会认为类别之间是有序的，但实际却是无序的。(例如：浏览器的类别数据是任意排序的)。

4.2 OneHotEncoder()

另外一种将标称型特征转换为能够被scikit-learn中模型使用的编码是one-of-K， 又称为 独热码或dummy encoding。 这种编码类型已经在类OneHotEncoder中实现。该类把每一个具有n_categories个可能取值的categorical特征变换为长度为n_categories的二进制特征向量，里面只有一个地方是1，其余位置都是0。

>>>
>>> enc = preprocessing.OneHotEncoder()
>>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']]
>>> enc.fit(X)  
OneHotEncoder(categorical_features=None, categories=None,
       dtype=<... 'numpy.float64'>, handle_unknown='error',
       n_values=None, sparse=True)
>>> enc.transform([['female', 'from US', 'uses Safari'],
...                ['male', 'from Europe', 'uses Safari']]).toarray()
array([[1., 0., 0., 1., 0., 1.],
       [0., 1., 1., 0., 0., 1.]])

5. 自定义转换器

在机器学习中，想要将一个已有的 Python 函数转化为一个转换器来协助数据清理或处理。可以使用 FunctionTransformer 从任意函数中实现一个转换器。例如，在一个管道中构建一个实现日志转换的转化器，这样做:

>>> import numpy as np
>>> from sklearn.preprocessing import FunctionTransformer
>>> transformer = FunctionTransformer(np.log1p, validate=True)
>>> X = np.array([[0, 1], [2, 3]])
>>> transformer.transform(X)
array([[0.        , 0.69314718],
       [1.09861229, 1.38629436]])

通过设置check_reverse=True并在转换之前调用fit，可以确保func和inverse_func是彼此的拟过程。请注意，请注意一个warning会被抛出，并且可以使用filterwarnings将其转为一个error

写在最后

1. 还有其他一些数据预处理的情况可以直接参考官方文档。

2. 在这之前还有特征提取的过程，后续再整理

3. 这篇主要是一些知识点的堆叠，还需要进行进一步地总结和提炼。