数据变换方法: 初值化、 均值化、百分比/倍数变换、归一化、极差最大值化、区间值...

浅夏110

特征归一化，又叫 特征缩放，Feature Normalization，Feature Scaling。各特征由于数值大小范围不一致，通过缩放特征的取值范围，可以消除量纲，使特征具有可比性。只有各特征之间的大小范围一致，才能使用距离度量等算法，加速梯度下降算法的收敛；在SVM算法中，一致化的特征能加速寻找支持向量的时间；不同的机器学习算法，能接受的输入数值范围不一样。sklearn中最常用的特征归一化方法是MinMaxScaler和StandardScaler。

) `+ J. s% a. t) W. d. Z  o1 w当我们需要将特征值都归一化为某个范围[a,b]时，选 MinMaxScaler
当我们需要归一化后的特征值均值为0，标准差为1，选 StandardScaler
- x  [8 G% n$ K- u. w+ C数据变换的目的：
( ?, \, r) p" h5 K$ Z  对收集来的原始数据必须进行数据变换和处理，主要是为了消除量纲，使其具有可比性。

定义 ： 设有n个数据的序列  ，则称映射
0 n, Z6 h* G% m+ Y9 c4 l
# I5 P3 J# Q- L+ T3 F! H- [                                       

% t5 Y! F4 y9 C. N- h          为序列 x到序列 y 的数据变换。

3 e% y4 K. E$ E# s, z数据变换的七种常见方式
5 j" d' G/ ^  E' s) x. d此处是对同一维度上的各个数据进行变换，如果数据有多个维度/属性，那就拆开来一个属性属性地变换，写成矩阵形式时，它也是分别对各维度进行操作。

# G5 [" d4 Y! W- j8 O  Z2 d初值化变换


也就是要对每一个数据，都除以第一个数据。

% o' G$ V7 }1 c; |, r, |均值化变换
4 j( b* V5 S1 `1 |3 P4 L+ P

             对每一个数据，都除以均值。
' ?& n9 k- J6 A' K
4 c" J; f! O/ d0 u2 e5 G1 L1 C/ \百分比变换
5 W/ w- n7 Q# q& j
4 T% F9 U) _  w& p8 S2 i4 d
4 z- j! O- _. W" k分母为x的该列属性中，值最大的那一个，使得变换后的值的绝对值，在[0,1]之间。
% |% B  u8 X$ E  b
" R4 s8 W; z! ~% x1 S% E  M倍数变换
+ t6 \# O: |9 N' d& K, g9 |   

0 H4 q2 g, h! o+ Z7 R- n归一化变换

3 o8 ^* L7 V1 X5 Z: C; N
% N0 w1 Y( r! H) |. i0 J2 ], x 其中   为大于零的某个值，称  是归一化变换。
: n/ k* Q, ?+ r1 J, A
6 y" C5 \$ \# J# _+ ]
/ g* q4 p+ T4 k5 Z* |极差最大值化变换

+ Z# H+ _. f; y& J

7 S1 g1 x0 {8 d( D( c) p
区间值化变换
5 `" f# B6 }0 F& j! v
/ [+ A! l' `  U( |
                  ,

1. matlab 的mapminmax归一化函数
函数用法：
7 _/ i: ^- [5 b8 X+ [, _; z8 }6 E [Xn,Xps]=mapminmax(X,min,max)
( k7 U* q: t/ Y3 H. L0 T. V
, ?3 b8 _1 W, B4 _) _说明：（1）该函数将X按行归一化，即计算某元素的归一化值时，最大最小值时该元素所处行的最大最小值；因此若只有一组观测时，X需是1*N的行向量。
9 A* e# z2 N$ Y& L% n
3 L4 Q2 K' q" N; b3 z　　　（2）min,max规定X的归一化范围，根据需要自行设置

　　　（3）ps是结构变量记录了归一化时的最大值最小值等参数，后续可重复调用　　　　　

　调用方法：

X1=mapminmax('apply', X_new,Xps);%利用先前的结构Xps进行相同的归一化
% E6 Y5 K6 H! R; F
X2=mapminmax('reverse',Xn, Xps);%反归一化
, E& N0 a, j& |: L( l
1 I  s' B8 z% r: X* A, Lx=[1,-1,2;　　　2,0,0;　　　0,1,-1]
- v' n! y% E/ C- g9 x$ M[x1,Xps]=mapminmax(x,0,1)
; ?' Z9 Q9 [) i7 o7 t2 P- x) V

- D7 t+ w5 H: `9 c4 f. Y  ?
* t8 k; t- i3 g9 _$ f3 s对于python中的axis=0 和axis=1的问题
如df.mean其实是在每一行上取所有列的均值，而不是保留每一列的均值。也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词（译者注）
换句话说:

使用0值表示沿着每一列或行标签\索引值向下执行方法
4 ^3 \% n; J( C, c% `( V: Y使用1值表示沿着每一行或者列标签模向执行对应的方法
0 C& i# g: r' r- c5 U; @
1 x8 b( E) G2 v1 R2 C2 p
) A* |  v& H7 W9 ]) ?  `) z
python的sklearn中 scale函数
; b: s5 o' w* b4 u1 标准化，均值去除和按方差比例缩放
0 `" A& ?2 v2 A6 X9 G              （Standardization, or mean removal and variance scaling）
2 i+ [  x1 }9 R/ _+ L3 \, ?3 i
3 z' z* J7 X9 A4 q; M　　数据集的标准化：当个体特征太过或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。

0 V7 f# Y5 G$ Q* dfrom sklearn import preprocessing
import numpy as np  
2 P* M% {1 h  ^! cX = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
X_scaled = preprocessing.scale(X)

#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
                                 [ 1.22474487  0.         -0.26726124]
$ \3 ?/ y) o: b! |2 d) Z3 }! W                                  [-1.22474487  1.22474487 -1.06904497]]
＃scaled之后的数据列为零均值，单位方差
X_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
2 Q, S, [. G( e6 U7 CX_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])


' k6 j4 i2 d# d4 a5 k
StandardScaler
# r3 X1 ^- t( ]* fStandardization即标准化，StandardScaler的归一化方式是用每个特征减去列均值，再除以列标准差。归一化后，矩阵每列的均值为0，标准差为1，形如标准正态分布（高斯分布）。 通过计算训练集的平均值和标准差，以便测试数据集使用相同的变换。（在numpy中，有std()函数用于计算标准差）
3 `  j- D, ^: r
( O8 L9 K5 b. _& Q- P4 Ffrom sklearn.preprocessing import StandardScaler
' L0 S; Z8 Y) Px=[[10001,2],[16020,4],[12008,6],[13131,8]]
X_scaler = StandardScaler()
X_train = X_scaler.fit_transform(x)
, A% j) u' ?, d" s& h& O; e9 @X_train
1 S7 g4 X* {9 r: s#结果如下
' i, [/ I% s/ A4 larray([[-1.2817325 , -1.34164079],
' s$ B* @7 b; {* `+ C( T       [ 1.48440157, -0.4472136 ],
) Y" J) O# \. h* G" X- L1 \       [-0.35938143,  0.4472136 ],
4 ]2 n0 \+ \2 Q. a       [ 0.15671236,  1.34164079]])
, H+ _' k( D$ @; Z4 p9 j; @( N2 |* Y: E
+ y! e+ q# c, g# n+ {
7 y. h. H& |1 }8 i# e6 ~+ e) z

注 ：

• 若设置with_mean=False 或者 with_std=False，则不做centering 或者scaling处理。
• scale和StandardScaler可以用于回归模型中的目标值处理。
  

from sklearn.preprocessing import StandardScaler
2 X! ^0 F- N7 S/ a; ex=[[10001,2],[16020,4],[12008,6],[13131,8]]
X_scaler = StandardScaler()
X_train = X_scaler.fit_transform(x)
X_train
/ R$ Q2 P9 B2 J* d) t) f1 J#结果如下
array([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
( ]# [  U+ E8 }4 I9 X3 q       [-0.35938143,  0.4472136 ],
2 s2 A4 b, d& I- w! _# V       [ 0.15671236,  1.34164079]])

scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
scaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
' h/ c- w' V- C/ ascaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913])
7 x$ f3 b6 [, U# v#测试将该scaler用于输入数据，变换之后得到的结果同上
scaler.transform(X)
# r& u8 a1 {. q: U. u+ m2 S9 h#out:
1 R# D' m/ B& d5 E, B* d  Earray([[ 0., -1.22474487,  1.33630621],
+ B, H! G- T, E& b- S4 x4 Q       [ 1.22474487, 0. , -0.26726124],
, Q: X4 k8 \% d2 F, |4 c, @: f       [-1.22474487,1.22474487, -1.06904497]])  
# E+ e- r5 W$ s8 ~; w" w1 o( y# L9 cscaler.transform([[-1., 1., 0.]])  #scale the new data
# out: array([[-2.44948974,  1.22474487, -0.26726124]])

) F6 t$ \8 e" y8 k2 将数据特征缩放至某一范围(scalingfeatures to a range)
0 Y+ U6 M3 e6 M2 C& e6 q( m) `

2.1 MinMaxScaler (最小最大值标准化)
它默认将每种特征的值都归一化到[0，1]之间，归一化后的数值大小范围是可调的（根据MinMaxScaler的参数feature_range调整）。  
! N9 [; h  W: U7 i3 j# }2 E/ b
2 _) X" @7 x+ h/ _* J  ~" r; d& U: Kfrom sklearn.preprocessing import MinMaxScaler
x=[[10001,2],[16020,4],[12008,6],[13131,8]]
7 B" g/ H8 x& N$ Q4 [( h3 n6 W6 I1 fmin_max_scaler = MinMaxScaler()
) o* [8 ?; Z$ f7 K8 x5 ?# ~4 ^X_train_minmax = min_max_scaler.fit_transform(x) #归一化后的结果，

$ s" V  C: P1 P' d% m, X0 ~min_max_scaler = MinMaxScaler(feature_range=(-1,1))
X_train_minmax = min_max_scaler.fit_transform(x) #归一化到(-1,1)上的结果
$ {' T+ D9 s( i. L
" c4 ~! U6 ^5 Z& m9 f" i3 YMinMaxScaler的实现
3 U# g1 O' u, [- h7 BX_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std / (max - min) + min

+ I7 S/ J; w. B# c这是 向量化的表达方式，说明X是矩阵，其中
7 w& m& r8 x; s  S* {
  d3 o+ @0 K6 D  W  D  YX_std：将X归一化到[0，1]之间
X.min(axis=0)表示列最小值
max，min表示MinMaxScaler的参数feature_range参数。即最终结果的大小范围

! o: I1 z+ T: Z# p5 l4 r# H  d( N3 S
2.2 MaxAbsScaler（绝对值最大标准化）
         与上述标准化方法相似，但是它通过除以最大值将训练集缩放至[-1,1]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据。

X_train = np.array([[ 1., -1.,  2.],
1 d5 _9 X4 j0 A# j+ }- n% f                     [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
- \3 U3 M2 F. O" n7 Z. G+ jmax_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
9 d1 C* }- Y1 ?# doctest +NORMALIZE_WHITESPACE^, out: array([[ 0.5, -1.,  1. ], [ 1. , 0. ,  0. ],       [ 0. ,  1. , -0.5]])
X_test = np.array([[ -3., -1.,  4.]])
- a$ f4 S0 h+ q- W0 p1 K6 R/ ZX_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
max_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])
7 q2 t' A7 D# b( R. m1 B  l& K


7 L; i; N5 F: [) |






/ ?0 U9 s/ Z; G- O: {————————————————
版权声明：本文为CSDN博主「wamg潇潇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
  ]5 d8 d6 H$ \6 g4 \5 t: a原文链接：https://blog.csdn.net/qq_29831163/article/details/89420223