[机器学习与scikit-learn-10]：数据预处理-3-数据的无量纲处理：StandardScaler、MinMaxScaler、MaxAbsScaler、RobustScaler

作者主页(​​文火冰糖的硅基工坊​​​)：​​文火冰糖（王文兵）的博客_文火冰糖的硅基工坊​

​目录​

​​第1章 数据的无量纲处理​​

​​1.1 概述​​

​​1.2 量纲化处理的好处​​

​​1.3 无量纲处理的分类​​

​​第2章 线性无量纲化​​

​​2.1 preprocessing.MinMaxScaler​​

​​2.2 MaxAbsScaler​​

​​2.3 RobustScaler：缩放有异常值的特征。​​

​​第3章 非线性变换：标准化StandardScaler​​

​​3.1 特征的标准化概述 ​​

​​3.2 代码案例​​

​​第4章 非线性变换：正则化Normalizer​​

​​4.1 概述​​

​​4.2 代码案例​​

第1章 数据的无量纲处理

1.1 概述

在机器学习算法实践中，我们往往有着将不同规格的数据转换到同一规格，或不同分布的数据转换到某个特定分布的需求，这种需求统称为将数据“无量纲化”。

1.2 量纲化处理的好处

在梯度和矩阵为核心的算法中，譬如逻辑回归，支持向量机，神经网络，无量纲化可以加快求解速度；

在距离类模型，譬如K近邻，K-Means聚类中，无量纲化可以帮我们提升模型精度，避免某一个取值范围特别大的特征对距离计算造成影响。（一个特例是决策树和树的集成算法们，对决策

树我们不需要无量纲化，决策树可以把任意数据都处理得很好。）

1.3 无量纲处理的分类

数据的无量纲化可以是线性的，也可以是非线性的。

​（1）线性无量纲化：所有数据按照相同的比率放缩​

线性的无量纲化包括中心化（Zero-centered或者Mean-subtraction）处理和缩放处理（Scale）。

• 中心化：本质是让所有记录减去一个固定值，即让数据样本数据平移到某个位置。
• 缩放：本质是通过除以一个固定值，将数据固定在某个范围之中，取对数也算是一种缩放处理。

​（2）非线性无量纲化：所有数据按照不同的比率放缩​

第2章 ​线性无量纲化​

2.1 preprocessing.MinMaxScaler

​（1）功能概述​

当数据(x)按照最小值中心化后，再按极差（最大值 - 最小值）缩放，数据移动了最小值个单位，并且会被收敛到[0,1]之间，而这个过程，就叫做数据归一化(Normalization，又称Min-Max Scaling)。

注意，Normalization是归一化，不是正则化，真正的正则化是regularization, 正则化之后的数据服从正态分布

在sklearn当中，我们使用preprocessing.MinMaxScaler来实现归一化这个功能。

把区间范围[min, max]缩放至[0,1]之间，也可以指定范围feature_range.

这种放缩方法，是把最小值转为0，最大值转为1，其它值在[0,1]之间​等比例​放缩。

​（2）代码实例​

from sklearn import preprocessing
import numpy as np

# 定义数据集
x = np.array([[3., -1., 2., 613.],
              [2., 0., 0., 5],
              [0., 1., -1., -113],
              [1., 2., -3., 6]])

# 定义放缩对象
min_max_scaler = preprocessing.MinMaxScaler()

# 开始放缩
x_minmax = min_max_scaler.fit_transform(x)

# 打印放缩后的结果
print(x_minmax)

[[1.         0.         1.         1.        ]
 [0.66666667 0.33333333 0.6        0.16253444]
 [0.         0.66666667 0.4        0.        ]
 [0.33333333 1.         0.         0.16391185]]

2.2 ​MaxAbsScaler​

​（1）功能概述​

把区间范围缩放至[-1,1]之间，无偏移。

这种放缩方法是，把绝对值最大的值映射到1或-1，到底是1还是-1, 取决于最大值的数值是正数还是负数。

• 0映射到0
• 【0，+绝对值最大值】被映射成【0,1】
• 【-绝对值最大值，0】被映射成【-1, 0】

 因此，这种方法称为绝对值放缩。

这种放缩方法，没有偏移，因此，这种方法​非常适合稀疏矩阵的放缩​。

​对于稀疏矩阵，如果使用StandardScaler和MinMaxScaler，它们会进行偏移，经过它们放缩后，会导致原先0的值，被变换成其他值，稀疏矩阵变成了非稀疏矩阵。​

​（2）代码实现​

from sklearn import preprocessing
import numpy as np

# 定义数据集
x = np.array([[3., -1., 2., 613.],
              [2., 0., 0., 5],
              [0., 1., -1., -113],
              [1., 2., -3., 6]])

# 定义放缩对象
MaxAbs_scaler = preprocessing.MaxAbsScaler()

# 开始放缩
x_MaxAbs = MaxAbs_scaler.fit_transform(x)

# 打印放缩后的结果
print(x_MaxAbs)

[[ 1.         -0.5         0.66666667  1.        ]
 [ 0.66666667  0.          0.          0.00815661]
 [ 0.          0.5        -0.33333333 -0.18433931]
 [ 0.33333333  1.         -1.          0.00978793]]

​2.3 RobustScaler​：缩放有异常值的特征。

​（1）功能概述​

如果数据中，有异常数据，如绝对值特别大的数据，如果把他们作为正常数据，会导致其他数据放缩后，非常非常的小，接近于0。这种情况，就不能以按照正常数据处理，把他们放缩到指定的区间，而应该亦然把他们作为异常数据处理，只需要把正常数据映射到指定区间即可，异常数据正常数据的放缩比例来进行等比例放缩，放缩后，它们依然是异常数据。

如果告诉放缩器，什么是正常数据和异常数据呢？或者说，放缩器按照什么规则判断是异常数据还是正常数据呢？它是通过quantile_range[?%, ?%] 两个百分比来指定哪些是异常值的。

RobustScale(…)

• with_centering : 布尔值，默认为True。若为True，则在缩放之前将数据居中。若使用稀疏矩阵时，此转换将引发异常，因为将其居中需要建立一个密集的矩阵，在通常情况下，该矩阵可能太大而无法容纳在内存中。
• with_scaling : 布尔值，默认为True。若为True，则将数据缩放到四分位数范围。
• quantile_range : tuple (q_min, q_max)。默认值：（25.0，75.0）=（第一分位数，第三分位数）
• copy : 布尔值，是否拷贝一份数据以避免在原数据上进行操作，默认为True
• RobustScale. center_

• 训练集中每个属性的中位数

• RobustScale. scale_

• 训练集中每个属性的四分位间距

​（2）代码实现​

from sklearn import preprocessing
import numpy as np

# 定义数据集
x = np.array([[3., -1., 2., 613.],
              [2., 0., 0., 50],
              [0., 1., -1., -113],
              [1., 2., -3., 6]])

# 定义放缩对象
robust_scaler = preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)

# 开始放缩
x_robust = robust_scaler.fit_transform(x)

# 打印放缩后的结果
print(x_MaxAbs)

[[ 1.         -1.          1.25        2.72727273]
 [ 0.33333333 -0.33333333  0.25        0.1025641 ]
 [-1.          0.33333333 -0.25       -0.65734266]
 [-0.33333333  1.         -1.25       -0.1025641 ]]

# x为一个具有异常值的数据
x = np.array([10,1000,0,0,-30,0,20,0,10,0,0,-10])
print(x)
print("")
x = x.reshape(-1,1)
print(x)

[  10 1000    0    0  -30    0   20    0   10    0    0  -10]

[[  10]
 [1000]
 [   0]
 [   0]
 [ -30]
 [   0]
 [  20]
 [   0]
 [  10]
 [   0]
 [   0]
 [ -10]]

# RobustScaler缩放有异常值的特征
# 1. 定义放缩对象
robustscaler = preprocessing.RobustScaler(with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)

# 放缩数据
y = robustscaler.fit_transform(x)

# 打印放缩后的数据
print(y)

[[  1.]
 [100.]
 [  0.]
 [  0.]
 [ -3.]
 [  0.]
 [  2.]
 [  0.]
 [  1.]
 [  0.]
 [  0.]
 [ -1.]]

第3章 非线性变换：标准化​StandardScaler​

​3.1 特征的标准化概述 ​

特征的标准化指的是将数据集的特征进行某种非线性缩放和偏移。

在许多情况下，特征的标准化可以改善机器学习算法的性能和效率。

缩放至均值u=0，标准差=1的。

特别说明：

标准化后的数据并非全部在[0,1]之间，数据在空间中的分布服从标准正态分布，大部分数据落在标准差1以内，还有大量的数据分布在1之外。

​3.2 代码案例​

​# 加载相应的库​

import numpy as np
import pandas as pd
%matplotlib inline
from sklearn import datasets
from sklearn import preprocessing

​# 显示原始数据​

boston = datasets.load_boston()

df = pd.DataFrame(data = boston.data, columns = list(boston.feature_names))

df.plot(legend = True)

房价（纵轴）数据

在[0, 700]

​# 显示标准后后的数据​

# StandardScaler缩放
# 1. 定义一个放缩数据的对象
standard_scaler = preprocessing.StandardScaler()

# 2. 把该对象绑定到特定的数据集上
standard_scaler.fit(df.values)

# 3. 对源数据进行放缩
data = standard_scaler.transform(df.values)

# 4. 构建可显示对象
dfscaled = pd.DataFrame(data,columns = list(boston.feature_names))

# 5. 显示数据
dfscaled.plot(legend = True)

 # 与​MinMaxScaler的比较​

# MinMax缩放
# 1. 定义一个放缩数据的对象
minmaxscaler = preprocessing.MinMaxScaler(feature_range = (0,1))

# 2. 把该对象绑定到特定的数据集上
minmaxscaler.fit(df.values)

# 3. 对源数据进行放缩
data = minmaxscaler.transform(df.values)

# 4. 构建可显示对象
dfscaled = pd.DataFrame(data,columns = list(boston.feature_names))

# 5. 显示数据
dfscaled.plot(legend = True)

备注：缩放后，房价数据被压缩到了[0,1]之间。 

第4章 非线性变换：正则化Normalizer

​4.1 概述​

正则化，也称为正规化，有时也叫归一化（不够准确，正则化是归一化的其中的一种方法)。

正则化是把样本数据看成一个向量序列，然后使用一定的规则对序列中的所有样本数据进行缩放，这个规则就是“范数”。“范数”常常被用来度量某个向量空间（或矩阵）中的每个向量的长度或大小的方法。

范数：就是按照某种算法，获得向量的长度值。

1范数：把向量分量绝对值的和作为长度，称为1范数

2范数：把向量分量绝对值的平方和，再开方，就是2范数。

p范数：把向量分量绝对值的p次方和，再开p次方，就是p范数。

无穷范数：当p无穷大时，范数的值接近于绝对值最大的分量。

正则化的目标：

• 所有向量的数据分量都小于1
• 所有向量的范数等于1

4.2 代码案例

​（1）待转换数据​

from sklearn import preprocessing

# 待转换数据
X = [[ 1., -1., 2.],
[ 2., 0., 0.],
[ 0., 1., -1.]]

​（2）按照1范数的方式正则化​

# 1范数
normalizer = preprocessing.Normalizer(norm = 'l1')
normalizer.fit(X) 
normalizer.transform(X)

array([[ 0.25, -0.25,  0.5 ],
       [ 1.  ,  0.  ,  0.  ],
       [ 0.  ,  0.5 , -0.5 ]])

备注：每一行向量的各个分量的绝对值和为1.

​（3）按照2范数的方式正则化​

# 2范数
# 方法1：使用normalize函数
X1 = preprocessing.normalize(X, norm='l2')
print(X1)

# 方法2：可以使用Normalizer类
normalizer = preprocessing.Normalizer(norm = 'l2')
#fit does nothing
normalizer.fit(X) 
X2 = normalizer.transform(X)
print(X2)

# 方法3：可以使用Normalizer类
normalizer = preprocessing.Normalizer(norm = 'l2')
X3 = normalizer.fit_transform(X)
print(X3)

[[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]
[[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]
[[ 0.40824829 -0.40824829  0.81649658]
 [ 1.          0.          0.        ]
 [ 0.          0.70710678 -0.70710678]]

备注：每一行向量的各个分量的二范数为1

作者主页(​​文火冰糖的硅基工坊​​​)：​​文火冰糖（王文兵）的博客_文火冰糖的硅基工坊​