python 机器学习的标准化、归一化、正则化、离散化和白化_Python

机器学习的本质是从数据集中发现数据内在的特征，而数据的内在特征往往被样本的规格、分布范围等外在特征所掩盖。数据预处理正是为了最大限度地帮助机器学习模型或算法找到数据内在特征所做的一系列操作，这些操作主要包括标准化、归一化、正则化、离散化和白化等。

1 标准化

假定样本集是二维平面上的若干个点，横坐标 x 分布于区间 [0,100] 内，纵坐标 y 分布于区间 [0,1] 内。显然，样本集的 x 特征列和 y 特征列的动态范围相差巨大，对于机器学习模型（如k-近邻或 k-means 聚类）的影响也会有显著差别。标准化处理正是为了避免某一个动态范围过大的特征列对计算结果造成影响，同时还可以提升模型精度。标准化的实质是对样本集的每个特征列减去该特征列均值进行中心化，再除以标准差进行缩放。
Scikit-learn的预处理子模块preprocessing提供了一个快速标准化函数scale()，使用该函数可以直接返回标准化后的数据集，其代码如下。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> d = np.array([[ 1., -5., 8.], [ 2., -3., 0.], [ 0., -1., 1.]])

									>>> d_scaled = pp.scale(d) # 对数据集d做标准化

									>>> d_scaled

									array([[ 0. , -1.22474487, 1.40487872],

									 [ 1.22474487, 0. , -0.84292723],

									 [-1.22474487, 1.22474487, -0.56195149]])

									>>> d_scaled.mean(axis=0) # 标准化以后的数据集，各特征列的均值为0

									array([0., 0., 0.])

									>>> d_scaled.std(axis=0) # 标准化以后的数据集，各特征列的标准差为1

									array([1., 1., 1.])

预处理子模块 preprocessing 还提供了一个实用类 StandardScaler，它保存了训练集上各特征列的平均值和标准差，以便以后在测试集上应用相同的变换。此外，实用类StandardScaler 还可以通过 with_mean 和 with_std 参数指定是否中心化和是否按标准差缩放，其代码如下。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> X_train = np.array([[ 1., -5., 8.], [ 2., -3., 0.], [ 0., -1., 1.]])

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

									>>> scaler

									StandardScaler(copy=True, with_mean=True, with_std=True)

									>>> scaler.mean_ # 训练集各特征列的均值

									array([ 1., -3., 3.])

									>>> scaler.scale_ # 训练集各特征列的标准差

									array([0.81649658, 1.63299316, 3.55902608])

									>>> scaler.transform(X_train) # 标准化训练集

									array([[ 0. , -1.22474487, 1.40487872],

									 [ 1.22474487, 0. , -0.84292723],

									 [-1.22474487, 1.22474487, -0.56195149]])

									>>> X_test = [[-1., 1., 0.]] # 使用训练集的缩放标准来标准化测试集

									>>> scaler.transform(X_test)

									array([[-2.44948974, 2.44948974, -0.84292723]])

2 归一化

标准化是用特征列的均值进行中心化，用标准差进行缩放。如果用数据集各个特征列的最小值进行中心化后，再按极差（最大值－最小值）进行缩放，即数据减去特征列的最小值，并且会被收敛到区间 [0,1] 内，这个过程就叫作数据归一化。
Scikit-learn的预处理子模块 preprocessing 提供 MinMaxScaler 类来实现归一化功能。MinMaxScaler 类有一个重要参数 feature_range，该参数用于设置数据压缩的范围，默认是 [0,1]。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> X_train = np.array([[ 1., -5., 8.], [ 2., -3., 0.], [ 0., -1., 1.]])

									>>> scaler = pp.MinMaxScaler().fit(X_train) # 默认数据压缩范围为[0,1]

									>>> scaler

									MinMaxScaler(copy=True, feature_range=(0, 1))

									>>> scaler.transform(X_train)

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

									 [1. , 0.5 , 0. ],

									 [0. , 1. , 0.125]])

									>>> scaler = pp.MinMaxScaler(feature_range=(-2, 2)) # 设置数据压缩范围为[-2,2]

									>>> scaler = scaler.fit(X_train)

									>>> scaler.transform(X_train)

									array([[ 0. , -2. , 2. ],

									 [ 2. , 0. , -2. ],

									 [-2. , 2. , -1.5]])

因为归一化对异常值非常敏感，所以大多数机器学习算法会选择标准化来进行特征缩放。在主成分分析（Principal Components Analysis，PCA）、聚类、逻辑回归、支持向量机、神经网络等算法中，标准化往往是最好的选择。归一化在不涉及距离度量、梯度、协方差计算，以及数据需要被压缩到特定区间时被广泛使用，如数字图像处理中量化像素强度时，都会使用归一化将数据压缩在区间 [0,1] 内。

3 正则化

归一化是对数据集的特征列的操作，而正则化是将每个数据样本的范数单位化，是对数据集的行操作。如果打算使用点积等运算来量化样本之间的相似度，那么正则化将非常有用。

Scikit-learn的预处理子模块preprocessing提供了一个快速正则化函数normalize()，使用该函数可以直接返回正则化后的数据集。normalize()函数使用参数norm指定I1范式或I2范式，默认使用I2范式。I1 范式可以理解为单个样本各元素的绝对值之和为 1；I2 范式可理解为单个样本各元素的平方和的算术根为 1，相当于样本向量的模（长度）。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> X_train = np.array([[ 1., -5., 8.], [ 2., -3., 0.], [ 0., -1., 1.]])

									>>> pp.normalize(X_train) # 使用I2范式正则化，每行的范数为1

									array([[ 0.10540926, -0.52704628, 0.84327404],

									 [ 0.5547002 , -0.83205029, 0. ],

									 [ 0. , -0.70710678, 0.70710678]])

									>>> pp.normalize(X_train, norm='I1') # 使用I1范式正则化，每行的范数为1

									array([[ 0.07142857, -0.35714286, 0.57142857],

									 [ 0.4 , -0.6 , 0. ],

									 [ 0. , -0.5 , 0.5 ]])

4 离散化

离散化（Discretization）是将连续特征划分为离散特征值，典型的应用是灰度图像的二值化。如果使用等宽的区间对连续特征离散化，则被称为 K-bins 离散化。Scikit-learn的预处理子模块preprocessing提供了Binarizer类和KbinsDiscretizer类来进行离散化，前者用于二值化，后者用于 K-bins 离散化。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> X = np.array([[-2,5,11],[7,-1,9],[4,3,7]])

									>>> bina = pp.Binarizer(threshold=5) # 指定二值化阈值为5

									>>> bina.transform(X)

									array([[0, 0, 1],

									 [1, 0, 1],

									 [0, 0, 1]])

									>>> est = pp.KBinsDiscretizer(n_bins=[2, 2, 3], encode='ordinal').fit(X)

									>>> est.transform(X) # 三个特征列离散化为2段、2段、3段

									array([[0., 1., 2.],

									 [1., 0., 1.],

									 [1., 1., 0.]])

5 白化

白化一词是从whitening翻译过来的，难以望文生义，只能从白化后的效果去理解。数据白化有两个目的，一是去除或降低特征列之间的相关性，二是使得每个特征列的方差为1。显然，白化的第一个目标就是主成分分析（PCA），通过主成分分析降维，消除方差占比较小的特征维；白化的第二个目标就是标准化。

白化分为PCA白化和ZCA白化两种。PCA 白化将原数据各个特征维变换到主成分轴上，消除了特征之间的相关性，并使得各个主成分的方差为1。ZCA白化则是将PCA 白化的结果反变换到原数据的各个特征维轴上，因为ZCA白化过程中通常不会降维。

Scikit-learn没有提供专用的白化方法，不过借助成分分析子模块decomposition提供的PCA 类可以轻松实现PCA白化。PCA类的参数whiten用于设置是否移除特征间的线性关联，默认值为False。

假如一位姑娘手头有一堆相亲资料，每位帅哥的信息由年龄、身高、体重、年薪、房产数量、汽车数量等多个特征项组成。通过白化操作，能够生成一个特征维较小、且可以直接比较样本间差距的数据集。

				?

									>>> import numpy as np

									>>> from sklearn import preprocessing as pp

									>>> from sklearn.decomposition import PCA

									>>> ds = np.array([

									    [25, 1.85, 70, 50, 2, 1], 

									    [22, 1.78, 72, 22, 0, 1], 

									    [26, 1.80, 85, 25, 1, 0],

									    [28, 1.70, 82, 100, 5, 2]

									]) # 4个样本，6个特征列

									>>> m = PCA(whiten=True) # 实例化主成分分析类，指定白化参数

									>>> m.fit(ds) # 主成分分析

									PCA(whiten=True)

									>>> d = m.transform(ds) # 返回主成分分析结果

									>>> d # 特征列从6个降至4个

									array([[ 0.01001541, -0.99099492, -1.12597902, -0.03748764],

									       [-0.76359767, -0.5681715 ,  1.15935316,  0.67477757],

									       [-0.65589352,  1.26928222, -0.45686577, -1.8639689 ],

									       [ 1.40947578,  0.28988421,  0.42349164,  1.2724972 ]])

									>>> d.std(axis=0) # 显示各特征列方差

									array([0.8660254 , 0.8660254 , 0.8660254 , 1.17790433])

									>>> d = pp.scale(d) # 标准化

									>>> d.std(axis=0) # 标准化后的各特征列方差均为1

									array([1., 1., 1., 1.])