前言

sklearn 中的 sklearn.preprocessing 中提供了数据预处理的相关函数，本文将主要围绕特征缩放来展开讲解。

一、标准化（StandardScaler）

设数据矩阵为

X = [ x 1 T x 2 T ⋮ x n T ] X= begin{bmatrix} boldsymbol{x}_1^{mathrm T} \ boldsymbol{x}_2^{mathrm T} \ vdots \ boldsymbol{x}_n^{mathrm T} end{bmatrix} X=⎣⎢⎢⎢⎡​x1T​x2T​⋮xnT​​⎦⎥⎥⎥⎤​

其中 x i = ( x i 1 , x i 2 , ⋯   , x i d ) T boldsymbol{x}_i=(x_{i1}, x_{i2},cdots,x_{id})^{mathrm T} xi​=(xi1​,xi2​,⋯,xid​)T 为特征向量。

在进行下一步之前，我们有必要先引入数据矩阵的均值和标准差。

我们知道，对于数据向量 a = ( a 1 , ⋯   , a n ) T boldsymbol{a}=(a_1,cdots,a_n)^{mathrm T} a=(a1​,⋯,an​)T 而言（这里的向量可以理解成一组数据，之所以称之为向量，是为了方便后续的表述），其均值和标准差分别为：

μ ( a ) = a 1 + ⋯ + a n n , σ ( a ) = ( 1 n ∥ a − μ ( a ) ∥ 2 ) 1 / 2 , 其 中    μ ( a ) = ( μ ( a ) , ⋯   , μ ( a ) ⏟ n 个 ) T mu(boldsymbol{a})=frac{a_1+cdots+a_n}{n},quadsigma(boldsymbol a)=left(frac1n Vert boldsymbol{a}-boldsymbol{mu}(boldsymbol{a})Vert^2right)^{1/2},quad 其中 ;boldsymbol{mu}(boldsymbol{a})=(underbrace{mu(boldsymbol{a}),cdots, mu(boldsymbol{a})}_{n 个})^{mathrm T} μ(a)=na1​+⋯+an​​,σ(a)=(n1​∥a−μ(a)∥2)1/2,其中μ(a)=(n个 μ(a),⋯,μ(a)​​)T

我们将 $X$ 写成行向量的形式： X = ( a 1 , a 2 , ⋯   , a d ) X =(boldsymbol{a}_1,boldsymbol{a}_2,cdots,boldsymbol{a}_d) X=(a1​,a2​,⋯,ad​)，其中每个 a i boldsymbol{a}_i ai​ 均为列向量，因此

μ ( X ) = ( μ ( a 1 ) , μ ( a 2 ) , ⋯   , μ ( a d ) ) T σ ( X ) = ( σ ( a 1 ) , σ ( a 2 ) , ⋯   , σ ( a d ) ) T begin{aligned} mu(X)&=(mu(boldsymbol{a}_1),mu(boldsymbol{a}_2),cdots,mu(boldsymbol{a}_d))^{mathrm T} \ sigma(X)&=(sigma(boldsymbol{a}_1),sigma(boldsymbol{a}_2),cdots,sigma(boldsymbol{a}_d))^{mathrm T} end{aligned} μ(X)σ(X)​=(μ(a1​),μ(a2​),⋯,μ(ad​))T=(σ(a1​),σ(a2​),⋯,σ(ad​))T​

设对 $X$ 进行标准化后得到 $Z$，利用 numpy 的广播机制，$Z$ 有如下形式

Z = ( z 1 , z 2 , ⋯   , z d ) , 其 中    z i = a i − μ ( a i ) σ ( a i ) ,      i = 1 , 2 , ⋯   , d Z=(boldsymbol{z}_1,boldsymbol{z}_2,cdots,boldsymbol{z}_d),quad 其中; boldsymbol{z}_i=frac{boldsymbol{a}_i-mu(boldsymbol{a}_i)}{sigma(boldsymbol{a}_i)},;;i=1,2,cdots,d Z=(z1​,z2​,⋯,zd​),其中zi​=σ(ai​)ai​−μ(ai​)​,i=1,2,⋯,d

当然 $Z$ 可以更为简洁地表成

Z = X − μ ( X ) T σ ( X ) T Z=frac{X-mu(X)^{mathrm T}}{sigma(X)^{mathrm T}} Z=σ(X)TX−μ(X)T​

---

查看 $X$ 的均值，方差和标准差：

from sklearn.preprocessing import StandardScaler
import numpy as np

# 数据矩阵
X = np.array([
    [1, 3],
    [0, 1]
])
# 创建一个scaler实例并将数据传入该实例中
scaler = StandardScaler().fit(X)
# 查看X的的均值，方差和标准差
print(scaler.mean_)  # [0.5 2. ]
print(scaler.var_)  # [0.25 1.  ]
print(scaler.scale_)  # [0.5 1. ]

之所以标准差为 scale_，是因为标准差控制着我们数据的缩放程度。需要注意的是，如果数据矩阵的某一列方差为 $0$，则 scale_ 为 $1$，即这一列不进行缩放。

对 $X$ 进行标准化，只需要使用 transfrom() 方法：

X = np.array([
    [243, 80],
    [19, 47]
])
scaler = StandardScaler().fit(X)
# 进行缩放
X_scaled = scaler.transform(X)
# [[ 1.  1.]
#  [-1. -1.]]

查看 X_scaled 的均值和标准差：

print(X_scaled.mean(axis=0))
# [0. 0.]
print(X_scaled.std(axis=0))
# [1. 1.]

可以看到 X_scaled 均值为 $0$， 标准差为 $1$，即 $X$ 已经标准化。

当然我们也可以用 scaler 去标准化新的样本，标准化过程采用 $X$ 的均值和标准差：

X = np.array([
    [243, 80],
    [19, 47]
])
scaler = StandardScaler().fit(X)
# 缩放新的样本
print(scaler.transform([[2, 3]]))
# [[-1.15178571 -3.66666667]]

二、归一化（MinMaxScaler）

对 $X$ 进行归一化就是将 $X$ 中的所有元素缩放至 $[0,1]$ 内。具体过程如下：

记

a i ‾ = min ⁡ ( x 1 i , x 2 i , ⋯   , x n i ) , a i ‾ = max ⁡ ( x 1 i , x 2 i , ⋯   , x n i ) X ‾ = ( a 1 ‾ , a 2 ‾ , ⋯   , a d ‾ ) T , X ‾ = ( a 1 ‾ , a 2 ‾ , ⋯   , a d ‾ ) T underline{boldsymbol{a}_i}=min(x_{1i},x_{2i},cdots,x_{ni}),quad overline{boldsymbol{a}_i}=max(x_{1i},x_{2i},cdots,x_{ni}) \ \ underline{X}=(underline{boldsymbol{a}_1},underline{boldsymbol{a}_2},cdots,underline{boldsymbol{a}_d})^{mathrm{T}},quad overline{X}=(overline{boldsymbol{a}_1},overline{boldsymbol{a}_2},cdots,overline{boldsymbol{a}_d})^{mathrm{T}} ai​​=min(x1i​,x2i​,⋯,xni​),ai​​=max(x1i​,x2i​,⋯,xni​)X​=(a1​​,a2​​,⋯,ad​​)T,X=(a1​​,a2​​,⋯,ad​​)T

设 $X$ 进行归一化后得到 $Z$，利用 numpy 的广播机制，我们有

Z = X − X ‾ T X ‾ T − X ‾ T Z=frac{X-underline{X}^{mathrm T}}{overline{X}^{mathrm T}-underline{X}^{mathrm T}} Z=XT−X​TX−X​T​

---

先用 make_blobs() 生成斑点数据集：

from sklearn.preprocessing import MinMaxScaler
from sklearn.datasets import make_blobs

X, _ = make_blobs(n_samples=6, centers=2, random_state=27)
print(X)
# [[ 5.93412904  6.82960749]
#  [-1.66484812  6.53450678]
#  [-1.26216614  6.23733539]
#  [ 5.26739446  7.73680694]
#  [-0.66451524  7.50872847]
#  [ 4.14680663  6.35238034]]

对 $X$ 进行归一化：

scaler = MinMaxScaler().fit(X)
print(scaler.transform(X))
# [[1.         0.39498722]
#  [0.         0.19818408]
#  [0.0529916  0.        ]
#  [0.91225996 1.        ]
#  [0.13164046 0.8478941 ]
#  [0.76479434 0.07672366]]

如果我们想将 $X$ 中的元素缩放至 $(1,2)$ 区间内，只需要：

scaler = MinMaxScaler((1, 2)).fit(X)
print(scaler.transform(X))
# [[2.         1.39498722]
#  [1.         1.19818408]
#  [1.0529916  1.        ]
#  [1.91225996 2.        ]
#  [1.13164046 1.8478941 ]
#  [1.76479434 1.07672366]]

三、正则化（Normalizer）

对 $X$ 进行正则化也就是对其中的每个样本（每一行）进行正则化，即将每个样本的范数化为单位范数。具体过程如下：

x i : = x i ∥ x i ∥ p , i = 1 , 2 , ⋯   , n , p = 1 , 2 , ∞ boldsymbol{x}_i:=frac{boldsymbol{x}_i}{Vert boldsymbol{x}_iVert_p},quad i=1,2,cdots,n,quad p=1,2,infty xi​:=∥xi​∥p​xi​​,i=1,2,⋯,n,p=1,2,∞

$p=1$ 时即为 L1 范数，$p=2$ 时即为 L2 范数，$p=\infty$ 时为无穷（最大）范数。Normalizer 默认采用 L2 范数。

---

对 $X$ 进行 L2 正则化：

from sklearn.preprocessing import Normalizer
import numpy as np

X = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8]
])
scaler = Normalizer().fit(X)
print(scaler.transform(X))
# [[0.18257419 0.36514837 0.54772256 0.73029674]
#  [0.37904902 0.45485883 0.53066863 0.60647843]]

如果要采用最大范数或 L1 范数，只需要：

scaler = Normalizer('max').fit(X)
print(scaler.transform(X))
# [[0.25  0.5   0.75  1.   ]
#  [0.625 0.75  0.875 1.   ]]

scaler = Normalizer('l1').fit(X)
print(scaler.transform(X))
# [[0.1        0.2        0.3        0.4       ]
#  [0.19230769 0.23076923 0.26923077 0.30769231]]

四、绝对值最大标准化（MaxAbsScaler）

对 $X$ 进行绝对值最大标准化即对 $X$ 的每一列，根据其最大绝对值进行缩放。具体过程如下：

记

M a x A b s ( a i ) = max ⁡ ( ∣ x 1 i ∣ , ∣ x 2 i ∣ , ⋯   , ∣ x n i ∣ ) , M a x A b s ( X ) = ( M a x A b s ( a 1 ) , ⋯   , M a x A b s ( a d ) ) T mathrm{MaxAbs}(boldsymbol{a_i})=max(|x_{1i}|,|x_{2i}|,cdots,|x_{ni}|),quad mathrm{MaxAbs}(X)=(mathrm{MaxAbs}(boldsymbol{a}_1),cdots, mathrm{MaxAbs}(boldsymbol{a}_d))^{mathrm T} MaxAbs(ai​)=max(∣x1i​∣,∣x2i​∣,⋯,∣xni​∣),MaxAbs(X)=(MaxAbs(a1​),⋯,MaxAbs(ad​))T

设 $X$ 进行绝对值最大标准化后得到 $Z$，利用 numpy 的广播机制，有

Z = X M a x A b s ( X ) T Z=frac{X}{mathrm{MaxAbs}(X)^{mathrm T}} Z=MaxAbs(X)TX​

---

对 $X$ 进行绝对值最大标准化：

from sklearn.preprocessing import MaxAbsScaler
import numpy as np

X = np.array([
    [1, -1, 2],
    [2, 0, 0],
    [0, 1, -1]
])
scaler = MaxAbsScaler().fit(X)
print(scaler.transform(X))
# [[ 0.5 -1.   1. ]
#  [ 1.   0.   0. ]
#  [ 0.   1.  -0.5]]

五、二值化（Binarizer）

对 $X$ 进行二值化就是设定一个阈值，$X$ 中大于该阈值的元素置为 $1$，小于等于该阈值的元素置为 $0$。

Binarizer 默认的阈值为 $0$。

---

对 $X$ 进行二值化：

from sklearn.preprocessing import Binarizer
import numpy as np

X = np.array([
    [1, -1, 2],
    [2, 0, 0],
    [0, 1, -1]
])
transformer = Binarizer().fit(X)
print(transformer.transform(X))
# [[1 0 1]
#  [1 0 0]
#  [0 1 0]]

若将阈值调为 $1$，则结果变成：

transformer = Binarizer(threshold=1).fit(X)
print(transformer.transform(X))
# [[0 0 1]
#  [1 0 0]
#  [0 0 0]]

事实上，利用 numpy 的特性，我们可以只用 numpy 完成这些操作：

import numpy as np

def binarizer(X, threshold):
    Y = X.copy()
    Y[Y > threshold] = 1
    Y[Y <= threshold] = 0
    return Y


X = np.array([
    [1, -1, 2], 
    [2, 0, 0], 
    [0, 1, -1]
])
print(binarizer(X, 0))
# [[1 0 1]
#  [1 0 0]
#  [0 1 0]]