目录
前言
在现实任务中，我们的数据集往往存在各种各样的问题，如果不对数据进行预处理，模型就无法得到有效的训练。
例如，对于神经网络而言，权重矩阵和阈值向量一般都是在
(0,1)(0,1)(0,1) 范围内初始化。如果输入的特征向量的某些分量过大或过小，可能会导致神经网络无法学习到一些重要的特征，因此有必要对输入的向量进行**特征缩放**。
sklearn 中的
sklearn.preprocessing
中提供了数据预处理的相关函数，本文将主要围绕特征缩放来展开讲解。
一、标准化（StandardScaler）
设数据矩阵为
X=[x1Tx2T⋮xnT]X= \begin{bmatrix} \boldsymbol{x}_1^{\mathrm T} \\ \boldsymbol{x}_2^{\mathrm T} \\ \vdots \\ \boldsymbol{x}_n^{\mathrm T} \end{bmatrix}X=⎣⎢⎢⎢⎡x1Tx2T⋮xnT⎦⎥⎥⎥⎤
其中
xi=(xi1,xi2,⋯,xid)T\boldsymbol{x}_i=(x_{i1}, x_{i2},\cdots,x_{id})^{\mathrm T}xi=(xi1,xi2,⋯,xid)T 为特征向量。
在进行下一步之前，我们有必要先引入数据矩阵的均值和标准差。
我们知道，对于数据向量
a=(a1,⋯,an)T\boldsymbol{a}=(a_1,\cdots,a_n)^{\mathrm T}a=(a1,⋯,an)T 而言（这里的向量可以理解成一组数据，之所以称之为向量，是为了方便后续的表述），其均值和标准差分别为：μ(a)=a1+⋯+ann,σ(a)=(1n∥a−μ(a)∥2)1/2,其中μ(a)=(μ(a),⋯,μ(a)⏟n个)T\mu(\boldsymbol{a})=\frac{a_1+\cdots+a_n}{n},\quad\sigma(\boldsymbol a)=\left(\frac1n \Vert \boldsymbol{a}-\boldsymbol{\mu}(\boldsymbol{a})\Vert^2\right)^{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
我们将
XXX 写成行向量的形式：X=(a1,a2,⋯,ad)X =(\boldsymbol{a}_1,\boldsymbol{a}_2,\cdots,\boldsymbol{a}_d)X=(a1,a2,⋯,ad)，其中每个ai\boldsymbol{a}_iai 均为列向量，因此μ(X)=(μ(a1),μ(a2),⋯,μ(ad))Tσ(X)=(σ(a1),σ(a2),⋯,σ(ad))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
设对
XXX 进行标准化后得到ZZZ，利用 numpy 的广播机制，ZZZ 有如下形式Z=(z1,z2,⋯,zd),其中zi=ai−μ(ai)σ(ai),i=1,2,⋯,dZ=(\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,dZ=(z1,z2,⋯,zd),其中zi=σ(ai)ai−μ(ai),i=1,2,⋯,d
当然
ZZZ 可以更为简洁地表成Z=X−μ(X)Tσ(X)TZ=\frac{X-\mu(X)^{\mathrm T}}{\sigma(X)^{\mathrm T}}Z=σ(X)TX−μ(X)T
查看
XXX 的均值，方差和标准差：
from sklearn.preprocessing import StandardScalerimport 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_
，是因为标准差控制着我们数据的缩放程度。需要注意的是，如果数据矩阵的某一列方差为
000，则
scale_
为
111，即这一列不进行缩放。
对
XXX 进行标准化，只需要使用
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\boldsymbol 00， 标准差为1\boldsymbol 11，即XXX 已经标准化。
当然我们也可以用
scaler
去标准化新的样本，标准化过程采用
XXX 的均值和标准差：
X = np.array([[243,80],[19,47]])scaler = StandardScaler().fit(X)# 缩放新的样本print(scaler.transform([[2,3]]))# [[-1.15178571 -3.66666667]]
二、归一化（MinMaxScaler）
对
XXX 进行归一化就是将XXX 中的所有元素缩放至[0,1][0,1][0,1] 内。具体过程如下：
记
ai‾=min(x1i,x2i,⋯,xni),ai‾=max(x1i,x2i,⋯,xni)X‾=(a1‾,a2‾,⋯,ad‾)T,X‾=(a1‾,a2‾,⋯,ad‾)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
设
XXX 进行归一化后得到ZZZ，利用 numpy 的广播机制，我们有Z=X−X‾TX‾T−X‾TZ=\frac{X-\underline{X}^{\mathrm T}}{\overline{X}^{\mathrm T}-\underline{X}^{\mathrm T}}Z=XT−XTX−XT
先用
make_blobs()
生成斑点数据集：
from sklearn.preprocessing import MinMaxScalerfrom sklearn.datasets import make_blobsX, _ = 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]]
对
XXX 进行归一化：
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]]
如果我们想将
XXX 中的元素缩放至(1,2)(1, 2)(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）
对
XXX 进行正则化也就是对其中的每个样本（**每一行**）进行正则化，即将每个样本的范数化为单位范数。具体过程如下：xi:=xi∥xi∥p,i=1,2,⋯,n,p=1,2,∞\boldsymbol{x}_i:=\frac{\boldsymbol{x}_i}{\Vert \boldsymbol{x}_i\Vert_p},\quad i=1,2,\cdots,n,\quad p=1,2,\inftyxi:=∥xi∥pxi,i=1,2,⋯,n,p=1,2,∞p=1p=1p=1 时即为 L1 范数，p=2p=2p=2 时即为 L2 范数，p=∞p=\inftyp=∞ 时为无穷（最大）范数。
Normalizer
默认采用 L2 范数。
对
XXX 进行 L2 正则化：
from sklearn.preprocessing import Normalizerimport numpy as npX = 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）
对
XXX 进行绝对值最大标准化即对XXX 的每一列，根据其最大绝对值进行缩放。具体过程如下：
记
MaxAbs(ai)=max(∣x1i∣,∣x2i∣,⋯,∣xni∣),MaxAbs(X)=(MaxAbs(a1),⋯,MaxAbs(ad))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
设
XXX 进行绝对值最大标准化后得到ZZZ，利用 numpy 的广播机制，有Z=XMaxAbs(X)TZ=\frac{X}{\mathrm{MaxAbs}(X)^{\mathrm T}}Z=MaxAbs(X)TX
对
XXX 进行绝对值最大标准化：
from sklearn.preprocessing import MaxAbsScalerimport numpy as npX = 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）
对
XXX 进行二值化就是设定一个阈值，XXX 中**大于**该阈值的元素置为111，**小于等于**该阈值的元素置为000。
Binarizer
默认的阈值为
000。
对
XXX 进行二值化：
from sklearn.preprocessing import Binarizerimport numpy as npX = 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]]
若将阈值调为
111，则结果变成：
transformer = Binarizer(threshold=1).fit(X)print(transformer.transform(X))# [[0 0 1]# [1 0 0]# [0 0 0]]
事实上，利用 numpy 的特性，我们可以只用 numpy 完成这些操作：
import numpy as npdefbinarizer(X, threshold):Y = X.copy()Y[Y > threshold]=1Y[Y <= threshold]=0return YX = np.array([[1,-1,2],[2,0,0],[0,1,-1]])print(binarizer(X,0))# [[1 0 1]# [1 0 0]# [0 1 0]]
参考
[1] https://scikit-learn.org/stable/modules/preprocessing.html#preprocessing.
本文转载自: https://blog.csdn.net/weixin_44022472/article/details/123346449
版权归原作者 serity 所有， 如有侵权，请联系我们删除。
版权归原作者 serity 所有， 如有侵权，请联系我们删除。