浅谈sklearn中的数据预处理

前言

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

一、标准化（StandardScaler）

设数据矩阵为

$$X=\left[\begin{array}{c}{\mathbf{x}}_1^{\mathrm{T}}\\ {\mathbf{x}}_2^{\mathrm{T}}\\ ⋮\\ {\mathbf{x}}_n^{\mathrm{T}}\end{array}\right]$$

其中 ${\mathbf{x}}_i=(x_{i1},x_{i2},\cdots ,x_{id}{)}^{\mathrm{T}}$ 为特征向量。

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

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

$$\mu (\mathbf{a})=\frac{a_1+\cdots +a_n}{n},\sigma (\mathbf{a})={\left(\frac{1}{n}\Vert \mathbf{a}-\mathbf{\mu }(\mathbf{a}){\Vert }^2\right)}^{1/2},其中\mathbf{\mu }(\mathbf{a})=(\underset{n个}{\mu (\mathbf{a}),\cdots ,\mu (\mathbf{a})}{)}^{\mathrm{T}}$$

我们将 $X$ 写成行向量的形式：$X=({\mathbf{a}}_1,{\mathbf{a}}_2,\cdots ,{\mathbf{a}}_d)$，其中每个 ${\mathbf{a}}_i$ 均为列向量，因此

$$\begin{array}{rl}\mu (X)& =(\mu ({\mathbf{a}}_1),\mu ({\mathbf{a}}_2),\cdots ,\mu ({\mathbf{a}}_d){)}^{\mathrm{T}}\\ \sigma (X)& =(\sigma ({\mathbf{a}}_1),\sigma ({\mathbf{a}}_2),\cdots ,\sigma ({\mathbf{a}}_d){)}^{\mathrm{T}}\end{array}$$

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

$$Z=({\mathbf{z}}_1,{\mathbf{z}}_2,\cdots ,{\mathbf{z}}_d),其中{\mathbf{z}}_i=\frac{{\mathbf{a}}_i-\mu ({\mathbf{a}}_i)}{\sigma ({\mathbf{a}}_i)},i=1,2,\cdots ,d$$

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

$$Z=\frac{X-\mu (X{)}^{\mathrm{T}}}{\sigma (X{)}^{\mathrm{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]$ 内。具体过程如下：

记

$$\begin{gathered} \underline{{\mathbf{a}}_i}=\min (x_{1i},x_{2i},\cdots ,x_{ni}),\overline{{\mathbf{a}}_i}=\max (x_{1i},x_{2i},\cdots ,x_{ni}) \\ \underline{X}=(\underline{{\mathbf{a}}_1},\underline{{\mathbf{a}}_2},\cdots ,\underline{{\mathbf{a}}_d}{)}^{\mathrm{T}},\overline{X}=(\overline{{\mathbf{a}}_1},\overline{{\mathbf{a}}_2},\cdots ,\overline{{\mathbf{a}}_d}{)}^{\mathrm{T}} \end{gathered}$$

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

$$Z=\frac{X-{\underline{X}}^{\mathrm{T}}}{{\overline{X}}^{\mathrm{T}}-{\underline{X}}^{\mathrm{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$ 进行正则化也就是对其中的每个样本（每一行）进行正则化，即将每个样本的范数化为单位范数。具体过程如下：

$${\mathbf{x}}_i:=\frac{{\mathbf{x}}_i}{\Vert {\mathbf{x}}_i{\Vert }_p},i=1,2,\cdots ,n,p=1,2,\infty$$

$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$ 的每一列，根据其最大绝对值进行缩放。具体过程如下：

记

$$\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{A}\mathrm{b}\mathrm{s}({\mathbf{a}}_{\mathbf{i}})=\max (|x_{1i}|,|x_{2i}|,\cdots ,|x_{ni}|),\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{A}\mathrm{b}\mathrm{s}(X)=(\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{A}\mathrm{b}\mathrm{s}({\mathbf{a}}_1),\cdots ,\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{A}\mathrm{b}\mathrm{s}({\mathbf{a}}_d){)}^{\mathrm{T}}$$

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

$$Z=\frac{X}{\mathrm{M}\mathrm{a}\mathrm{x}\mathrm{A}\mathrm{b}\mathrm{s}(X{)}^{\mathrm{T}}}$$

---

对 $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]]