这篇博文将详细讲下sklearn.preprocessing包是如何对数据进行预处理的，全文翻译自sklearn.preprocessing，并且加上了我自己的一些见解。
sklearn.preprocessing包提供了几个常见的实用函数和变换器类，以将原始特征向量转换为更适合分类器或者回归器的表示。
标准化，去均值和方差缩放
scikit-learn中的许多学习器都需要将数据集进行标准化处理。数据集的标准化：当个体特征太过或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。
例如，用于学习算法（例如支持向量机的RBF内核或线性模型的l1和l2正则化器）的目标函数中，假设所有特征都以零为中心并且具有相同量级的方差。如果某一个特征的方差大于其他数量级，则可能会对目标函数影响较大，使学习器无法按预期正确地学习其他特征。
函数scale提供了一种快速简单的方法来在单个阵列数据集上执行此操作：
公式为：(X-mean)/std 计算时对每个属性/每列分别进行。
将数据按期属性（按列进行）减去其均值，并处以其方差。得到的结果是，对于每个属性/每列来说所有数据都聚集在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...]])
缩放后的数据均值为0，方差为单位1
>>> X_scaled.mean(axis=0)
array([ 0., 0., 0.])
>>> X_scaled.std(axis=0)
array([ 1., 1., 1.])
preprocessing模块还提供了一个实用程序类StandardScaler，它实现了Transformer API来计算训练集上的平均值和标准偏差，使用该类的好处在于可以保存训练集中的参数（均值、方差）直接使用其对象转换测试集数据。
>>> scaler = preprocessing.StandardScaler().fit(X)
>>> scaler
StandardScaler(copy=True, with_mean=True, with_std=True)
>>> scaler.mean_ ##训练集上每个特征的均值
array([ 1. ..., 0. ..., 0.33...])
>>> scaler.scale_ ##训练集上每个特征相对缩放的程度
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...]])
注 ：
1）若设置with_mean=False 或者 with_std=False，则不做centering 或者scaling处理。
2）scale和StandardScaler可以用于回归模型中的目标值处理。
将特征缩放到某一个指定的范围
另一种标准化是将特征缩放到给定的最小值和最大值之间，通常在0到1之间，或者使得每个特征的最大绝对值被缩放到单位大小。这可以分别使用MinMaxScaler或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. ]])
>>> X_test = np.array([[ -3., -1., 4.]])
>>> X_test_minmax = min_max_scaler.transform(X_test)
>>> X_test_minmax
array([[-1.5 , 0. , 1.66666667]])
>>> min_max_scaler.scale_
array([ 0.5 , 0.5 , 0.33...])
>>> min_max_scaler.min_
array([ 0. , 0.5 , 0.33...])
当然，在构造类对象的时候也可以直接指定最大最小值的范围：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]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据。
>>> X_train = np.array([[ 1., -1., 2.],
... [ 2., 0., 0.],
... [ 0., 1., -1.]])
>>> max_abs_scaler = preprocessing.MaxAbsScaler()
>>> X_train_maxabs = max_abs_scaler.fit_transform(X_train)
>>> X_train_maxabs # doctest +NORMALIZE_WHITESPACE^
array([[ 0.5, -1. , 1. ],
[ 1. , 0. , 0. ],
[ 0. , 1. , -0.5]])
>>> X_test = np.array([[ -3., -1., 4.]])
>>> X_test_maxabs = max_abs_scaler.transform(X_test)
>>> X_test_maxabs
array([[-1.5, -1. , 2. ]])
>>> max_abs_scaler.scale_
array([ 2., 1., 2.])
就像scale，如果你不想创建一个类对象来进行标准化处理，你可以直接使用函数 minmax_scale 和maxabs_scale。
对稀疏数据的缩放
对稀疏数据进行中心化处理将破坏其稀疏结构，因此这并不是一件明智的事情。然而，缩放稀疏投入是有意义的，特别是如果特征在不同的尺度上。
MaxAbsScaler和maxabs_scale专门用于缩放稀疏数据。scale和StandardScaler也可以接受scipy.sparse矩阵作为输入，只要将__an = False显式传递给构造函数即可。否则将破坏数据稀疏性，抛出ValueError异常，并且经常会因为分配过多的内存而使执行崩溃。 RobustScaler不能被调用为稀疏输入，但是可以使用transform方法输入稀疏数据。
缩放带有离群点的数据
如果数据包含许多异常值，则使用数据的均值和方差进行缩放可能无法起到很好的效果。在这些情况下，可以使用robust_scale和RobustScaler替代。他们对数据的中心和范围使用更强大的估计。
正则化
正则化的过程是将每个样本缩放到单位范数（每个样本的范数为1），如果后面要使用如二次型（点积）或者其它核方法计算两个样本之间的相似性这个方法会很有用。
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
Sklearn里常用l1,l2范数。
数学表达式：
令x=(x1,x2,x3,…,Xn)T
L1范数：||x||1=|x1|+|x2|+…+|Xn|
L2范数：||x||2=(|x1|^2+|x2|^2+…+|xn|^2)^1/2
可以使用preprocessing.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...]])
可以使用processing.Normalizer()类实现对训练集和测试集的拟合和转换：
>>> 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. ...]])
二值化
特征二值化
特征二值化是对数值特征进行阈值处理以获取布尔值的过程。这对于概率学习器来说是有用的，它们假设输入数据符合多变量伯努利分布分布。例如，这是sklearn.neural_network.BernoulliRBM的情况。
就像上面说到的Normalizer类一样，同样有一个Binarizer类用来对数据进行二值化。
>>> 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)
>>> binarizer.transform(X)
array([[ 1., 0., 1.],
[ 1., 0., 0.],
[ 0., 1., 0.]])
也可以调整阈值进行二值化
>>> binarizer = preprocessing.Binarizer(threshold=1.1)
>>> binarizer.transform(X)
array([[ 0., 0., 1.],
[ 1., 0., 0.],
[ 0., 0., 0.]])
同样的，也可以不用创建类对象Binarizer，这里提供了方法binarize方法进行二值化。
缺失值填充
Imputer类提供了使用缺失值所在的行或列的均值，中值或最常用值来估算缺失值的基本策略。该类也允许不同的缺失值编码。
以下代码段演示了如何使用包含缺失值的列（轴0）的平均值来替换编码为np.nan的缺失值：
>>> 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. ]]
Imputer类同样支持稀疏矩阵
>>> 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. ]]
请注意，在这里，缺失值由0编码，因此隐式存储在矩阵中。因此，当比观察值更多的缺失值时，此格式是合适的。
生成多项式的特征
通过输入数据的非线性特征，常常增加模型的复杂性。一个简单而常用的方法是多项式特征，可以获得特征的高阶和交互项。它在PolynomialFeatures中实现：
>>> import numpy as np
>>> from sklearn.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
[2, 3],
[4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1., 0., 1., 0., 0., 1.],
[ 1., 2., 3., 4., 6., 9.],
[ 1., 4., 5., 16., 20., 25.]])
这些特征都是从(x1,x2)转换成(1,x1,x2,x1^2,x1*x2,x2^2)
有时候，只需要特征之间的交互项，可以设置interaction_only=True
注意：多项式有时会提高分类器的分类效果，但是如果阶数过高容易过拟合。一般多项式都是几个特征之间的二阶以上的关系，所以并不会产生冗余信息，冗余只是对特征之间一阶线性关系（例如ax1+bx2）而言。
>>> X = np.arange(9).reshape(3, 3)
>>> X
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> poly = PolynomialFeatures(degree=3, interaction_only=True)
>>> poly.fit_transform(X)
array([[ 1., 0., 1., 2., 0., 0., 2., 0.],
[ 1., 3., 4., 5., 12., 15., 20., 60.],
[ 1., 6., 7., 8., 42., 48., 56., 336.]])
这些特征都是从(x1,x2,x3)组合成（1,x1,x2,x3,x1*x2,x2*x3,x1*x3,x1*x2*x3）
自定义转换函数
通常，将需要将现有的Python函数转换为数据预处理函数，以协助数据清理或处理。可以使用FunctionTransformer从任意函数实现数据预处理函数。
>>> import numpy as np
>>> from sklearn.preprocessing import FunctionTransformer
>>> transformer = FunctionTransformer(np.log1p)
>>> X = np.array([[0, 1], [2, 3]])
>>> transformer.transform(X)
array([[ 0. , 0.69314718],
[ 1.09861229, 1.38629436]])
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
