数据规范化——sklearn.preprocessing

sklearn实现---归类为5大类

• sklearn.preprocessing.scale()（最常用，易受异常值影响）
• sklearn.preprocessing.StandardScaler()
• sklearn.preprocessing.minmax_scale()（一般缩放到[0,1]之间，若新数据集最大最小值范围有变，需重新minmax_scale）
• sklearn.preprocessing.MinMaxScaler()
• sklearn.preprocessing.maxabs_scale()（为稀疏数据而生）
• sklearn.preprocessing.MaxAbsScaler()
• sklearn.preprocessing.robust_scale()（为异常值而生）
• sklearn.preprocessing.RobustScaler()
• sklearn.preprocessing.normalize()(文本分类or聚类时常用，默认对样本正则化，上述4种默认对列，即特征来规范化）
• sklearn.preprocessing.preprocessing.Normalizer()

借用iris数据集

import pandas as pd
import numpy as np
from sklearn import datasets
iris  = datasets.load_iris()
x, y = iris.data, iris.target

print(x[:10])

[[ 5.1  3.5  1.4  0.2]
 [ 4.9  3.   1.4  0.2]
 [ 4.7  3.2  1.3  0.2]
 [ 4.6  3.1  1.5  0.2]
 [ 5.   3.6  1.4  0.2]
 [ 5.4  3.9  1.7  0.4]
 [ 4.6  3.4  1.4  0.3]
 [ 5.   3.4  1.5  0.2]
 [ 4.4  2.9  1.4  0.2]
 [ 4.9  3.1  1.5  0.1]]

print(x.shape,x.max(),x.min())

(150, 4) 7.9 0.1

官网对不同方法的比较文档：

https://scikit-learn.org/stable/auto_examples/preprocessing/plot_all_scaling.html#sphx-glr-auto-examples-preprocessing-plot-all-scaling-py

一.z-score 标准化(zero-mean normalization)

也叫标准差标准化。先减去均值，后除以均方根。提高了数据可比性，同时削弱了数据解释性，是用的最多的数据的标准化方法。输出：每个属性值均值为0，方差为1，呈正态分布。
公式如下：
x* = (x-μ)/σ
( 其中μ为所有样本数据的均值，σ为所有样本数据的标准差。)

使用原因：
部分机器学习算法求解目标函数时，要求特征的均值为0，方差为1.（如：SVM的RFB内核、线性模型的L1和L2正则化）此时，如果某个特征的方差比其他特征的方差大几个数量级别，如：3000:2等，会造成方差大的特征在算法中占据主导地位，使得机器学习效果不佳。

缺点：

• 当特征明显不遵从高斯正态分布时，标准化出来的效果较差。
• 还要注意，均值和标准差受离群点的影响很大，所以如果有很多异常值，使用RobustScaler或robust_scaler 的效果更好。
• scale和 StandardScaler都能接受 scipy.sparse 作为输入，但参数必须设置： with_mean=False。Or会报错： ValueError ，因为默认的中心化会破坏稀疏性，并且此时内存一般会炸，然后崩溃------>dead。
• 实际应用中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。

实现：

• sklearn.preprocessing.scale
• sklearn.preprocessing.StandardScaler（两个基本一样，但一般用这个就ok了，比较高级、方法比较齐全）

1.1 sklearn.preprocessing.scale(X, axis=0, with_mean=True, with_std=True, copy=True)

参数说明：
axis=0,默认。计算列。axis=1，则会按行进行标准化。
with_mean、with_std，默认为True，设置将数据转化成0均值、方差为1的标准正态分布，基本不用管。

from sklearn.preprocessing import scale
iris_scale = scale(x)
print(iris_scale[:5])  #显示4个被scale后的特征

[[-0.90068117  1.03205722 -1.3412724  -1.31297673]
 [-1.14301691 -0.1249576  -1.3412724  -1.31297673]
 [-1.38535265  0.33784833 -1.39813811 -1.31297673]
 [-1.50652052  0.10644536 -1.2844067  -1.31297673]
 [-1.02184904  1.26346019 -1.3412724  -1.31297673]]

print("平均值：",iris_scale.mean(axis=0))
print("样本方差：",iris_scale.std(axis=0))

平均值： [ -1.69031455e-15  -1.63702385e-15  -1.48251781e-15  -1.62314606e-15]
样本方差： [ 1.  1.  1.  1.]

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

from sklearn.preprocessing import StandardScaler
Stan_scaler = StandardScaler()
Stan_scaler.fit(x)
x_test = np.array([[6,4,6,2],
                  [4.999,3,5,2.3]])   #假设新的数据集，可当作我们平时用到的测试集
Stan_scaler.transform(x_test)

array([[ 0.18982966,  2.18907205,  1.27454998,  1.05353673],
       [-1.02306072, -0.1249576 ,  0.70589294,  1.44795564]])

transform时，用到的是原先x中的均值与标准差，相当于我们平时的训练集例的均值与标准差，然后用这两个值去标准化测试集的数据。

二.最小最大值标准化（将数据缩放到一定范围内）

公式如下：
x* = (x-min)/(max-min) （当使用默认[0,1]范围时）
( 其中min为特征的最小值，max为特征的最大值。)

使用原因：

• 对于方差非常小的属性可以增强其稳定性。有时数据集的标准差非常非常小，有时数据中有很多很多零（稀疏数据）需要保存住０元素。
• 维持稀疏矩阵中为0的条目。

缺点：
当数据出现新的最大最小值时，需要重来一遍。
若数值集中且某个数值很大，则规范化后各值接近于0，并且将会相差不大。（如：100、101、102、108、20001）

实现：

• sklearn.preprocessing.minmax_scale
• sklearn.preprocessing.MinMaxScaler(这两者的关系跟上面的标准差标准化差不多，这里只讲后者）

sklearn.preprocessing.MinMaxScaler(feature_range=(0, 1), copy=True)
官网文档：
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html#sklearn.preprocessing.MinMaxScaler
参数说明：
feature_range : tuple (min, max), default=(0, 1)
转化步骤如下：
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0)) #每列最大、最小值
X_scaled = X_std * (max - min) + min

from sklearn.preprocessing import MinMaxScaler
MiMaScaler = MinMaxScaler()
MiMaScaler.fit(x)
x_test = np.array([[4.563,4,6,2],
                  [4.999,3,3,1]])   #假设新的数据集，可当作我们平时用到的测试集
MiMaScaler.transform(x_test)    #如果新数据集中最大最小值超出原来fit的数据的最大最小值，请注意transform出来的数据将不在[0,1]内，需重新fit

array([[ 0.07305556,  0.83333333,  0.84745763,  0.79166667],
       [ 0.19416667,  0.41666667,  0.33898305,  0.375     ]])

举一个栗子（反例）：当transform的数据集的最大最小值超出fit数据集中的最大最小值

x_test_out = np.array([[9,10,77,88],
                      [33,29,10,3]])
MiMaScaler.transform(x_test_out) 

array([[  1.30555556,   3.33333333,  12.88135593,  36.625     ],
       [  7.97222222,  11.25      ,   1.52542373,   1.20833333]])

Obviously，转换出来的数据范围并不在[0,1]内。所以应用中需引起注意。

另外，说明一下：fit_transform存在的意义

1 MiMaScaler.fit(x)
2 MiMaScaler.transform(x)
3 MinMaxScaler().fit_transform(x)
注意第3句效果跟1、2句联合起来一样，第3句省一步，飞快实现转换~~

三.绝对值标准化（暂时这么叫）（将数据缩放到一定范围内，专为稀疏数据而生）

使用原因：
将每个要素缩放到[-1,1]范围，它不会移动/居中数据，因此不会破坏任何稀疏性。
该估计器单独地缩放每个特征，使得训练集中的每个特征的最大绝对值将是1.0。
该缩放器也可以应用于稀疏CSR或CSC矩阵。

实现：

• sklearn.preprocessing.maxabs_scale(X, axis=0, copy=True)
• sklearn.preprocessing.MaxAbsScaler(copy=True)（这两者的关系同上）

from sklearn.preprocessing import MaxAbsScaler
MaAbScaler = MaxAbsScaler().fit(x)
MaAbScaler.transform(x)[:10]

array([[ 0.64556962,  0.79545455,  0.20289855,  0.08      ],
       [ 0.62025316,  0.68181818,  0.20289855,  0.08      ],
       [ 0.59493671,  0.72727273,  0.1884058 ,  0.08      ],
       [ 0.58227848,  0.70454545,  0.2173913 ,  0.08      ],
       [ 0.63291139,  0.81818182,  0.20289855,  0.08      ],
       [ 0.6835443 ,  0.88636364,  0.24637681,  0.16      ],
       [ 0.58227848,  0.77272727,  0.20289855,  0.12      ],
       [ 0.63291139,  0.77272727,  0.2173913 ,  0.08      ],
       [ 0.55696203,  0.65909091,  0.20289855,  0.08      ],
       [ 0.62025316,  0.70454545,  0.2173913 ,  0.04      ]])

MaAbScaler.transform(x).max(axis=0)

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

每列值的Max值的绝对值将会是1.

四.鲁棒性标准化（暂时这么叫）（将数据缩放到一定范围内，专为异常值而生）

使用原因：
标准差标准化（第一种，最常用的那种）对数据中出现的异常值处理能力不佳，因此诞生了robust_scale，这种不怕异常值扰动的数据缩放法。
此Scaler根据分位数范围（默认为IQR：Interquartile Range）删除中位数并缩放数据。 IQR是第1四分位数（第25个分位数）和第3个四分位数（第75个分位数）之间的范围。

实现：

• sklearn.preprocessing.robust_scale(X, axis=0, with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)
• sklearn.preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)

from sklearn.preprocessing import RobustScaler
Robust_Scaler = RobustScaler()
Robust_Scaler.fit(x)
Robust_Scaler.transform(x)[:10]

array([[-0.53846154,  1.        , -0.84285714, -0.73333333],
       [-0.69230769,  0.        , -0.84285714, -0.73333333],
       [-0.84615385,  0.4       , -0.87142857, -0.73333333],
       [-0.92307692,  0.2       , -0.81428571, -0.73333333],
       [-0.61538462,  1.2       , -0.84285714, -0.73333333],
       [-0.30769231,  1.8       , -0.75714286, -0.6       ],
       [-0.92307692,  0.8       , -0.84285714, -0.66666667],
       [-0.61538462,  0.8       , -0.81428571, -0.73333333],
       [-1.07692308, -0.2       , -0.84285714, -0.73333333],
       [-0.69230769,  0.2       , -0.81428571, -0.8       ]])

五.正则化

使用原因：
每个样本被单独缩放，使得其范数等于1。注意，是对每个样本，不再像之前的（默认对列进行规范化）规范化。
文本分类或聚类中常用。可用于密集的numpy数组和scipy.sparse矩阵（如果你想避免复制/转换的负担，请使用CSR格式）
Normalization主要思想是对每个样本计算其p-范数，然后对该样本中每个元素除以该范数，这样处理的结果是使得每个处理后样本的p-范数（l1-norm,l2-norm）等于1。
p-范数的计算公式：||X||p=(|x1|^p+|x2|p+...+|xn|^p)1/p

实现：

• sklearn.preprocessing.normalize(X, norm=’l2’, axis=1, copy=True, return_norm=False)
• sklearn.preprocessing.Normalizer(norm=’l2’, copy=True)

5.1 sklearn.preprocessing.normalize(X, norm=’l2’, axis=1, copy=True, return_norm=False)

官方文档:
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.normalize.html#sklearn.preprocessing.normalize

5.2 sklearn.preprocessing.Normalizer(norm=’l2’, copy=True)

官方文档：
https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Normalizer.html#sklearn.preprocessing.Normalizer
参数说明：
norm :‘l1’,‘l2’, or ‘max’, 默认l2。

from sklearn.preprocessing import Normalizer
Normalizer_ = Normalizer()
Normalizer_.fit(x)
Normalizer_.transform(x)[:10]

array([[ 0.80377277,  0.55160877,  0.22064351,  0.0315205 ],
       [ 0.82813287,  0.50702013,  0.23660939,  0.03380134],
       [ 0.80533308,  0.54831188,  0.2227517 ,  0.03426949],
       [ 0.80003025,  0.53915082,  0.26087943,  0.03478392],
       [ 0.790965  ,  0.5694948 ,  0.2214702 ,  0.0316386 ],
       [ 0.78417499,  0.5663486 ,  0.2468699 ,  0.05808704],
       [ 0.78010936,  0.57660257,  0.23742459,  0.0508767 ],
       [ 0.80218492,  0.54548574,  0.24065548,  0.0320874 ],
       [ 0.80642366,  0.5315065 ,  0.25658935,  0.03665562],
       [ 0.81803119,  0.51752994,  0.25041771,  0.01669451]])

 0.80377277* 0.80377277+0.55160877*0.55160877+  0.22064351*0.22064351 +   0.0315205 * 0.0315205 

1.0000000013597559

下面验证一下每个样本的范数，随机挑选第四个样本、第77个样本来验证：

output_3 = []
aa = Normalizer_.transform(x)[3]
for i in aa:
    output_3.append(i*i)
print(output_3)
print("样本范数：",sum(output_3))

[0.64004839685420423, 0.29068360556563821, 0.068058076225045352, 0.0012099213551119174]
样本范数： 1.0

output_76 = []
bb = Normalizer_.transform(x)[76]
for i in bb:
    output_76.append(i*i)
print(output_76)
print("样本范数：",sum(output_76))

[0.58472432979261513, 0.099140111279716753, 0.29135053110773901, 0.024785027819929188]
样本范数： 1.0

拓：向量范数的内容：