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

浅夏110

特征归一化，又叫 特征缩放，Feature Normalization，Feature Scaling。各特征由于数值大小范围不一致，通过缩放特征的取值范围，可以消除量纲，使特征具有可比性。只有各特征之间的大小范围一致，才能使用距离度量等算法，加速梯度下降算法的收敛；在SVM算法中，一致化的特征能加速寻找支持向量的时间；不同的机器学习算法，能接受的输入数值范围不一样。sklearn中最常用的特征归一化方法是MinMaxScaler和StandardScaler。
- M1 I4 S/ ^& a7 v- a
当我们需要将特征值都归一化为某个范围[a,b]时，选 MinMaxScaler
当我们需要归一化后的特征值均值为0，标准差为1，选 StandardScaler
数据变换的目的：
6 c7 Z  ]; q' H; [3 p0 q  对收集来的原始数据必须进行数据变换和处理，主要是为了消除量纲，使其具有可比性。
( j2 V% q, j1 W2 X: F
" d; `. C4 e- m. I' ?# ~ 定义 ： 设有n个数据的序列  ，则称映射
: [8 B' _7 W9 O
% X8 P" P1 n0 a& R                                       
8 J( d$ h) I. x9 m6 S- w0 _
5 G# Y- Y3 O# y          为序列 x到序列 y 的数据变换。
$ I6 o# g: T* R. g: {
数据变换的七种常见方式
此处是对同一维度上的各个数据进行变换，如果数据有多个维度/属性，那就拆开来一个属性属性地变换，写成矩阵形式时，它也是分别对各维度进行操作。

初值化变换
1 v! {$ R, o2 O5 s+ P+ Q7 A

) X; o% B) \! B0 ]1 K 也就是要对每一个数据，都除以第一个数据。
9 [: ~( }& h& h6 H: _' ~; o
均值化变换
" ^) Q+ R2 x: l5 G! N; y6 \

             对每一个数据，都除以均值。

百分比变换


" y9 p" q3 z( c! B分母为x的该列属性中，值最大的那一个，使得变换后的值的绝对值，在[0,1]之间。

. ^: W* L4 y5 F5 m6 r倍数变换
/ n# L- a6 F8 F   
# W; g! J9 T, u5 Y% y  G9 s
+ B# g. I- {  A) y% }! |归一化变换

5 z' @. W9 T; y+ f4 [
其中   为大于零的某个值，称  是归一化变换。
! I9 c/ |! I0 T% w  J" c: B% Z
  `6 T3 |4 F" |% h) m6 n! Q9 x
! V1 [3 [/ R7 \4 |, l0 d  r0 o极差最大值化变换

: `8 k' X, M& F$ ]3 y5 a' R9 `
* w0 Z( i. s6 d' D1 D
$ a; Y7 b9 Q' p3 K: ?# D( \
区间值化变换
) F. Q9 s- v$ `. e8 y
4 N& [! j" R( \/ Y, D
4 Y; P; c; W+ n1 q/ O; h9 N  v                  ,

1. matlab 的mapminmax归一化函数
& \/ i. T" Y3 }' b: t+ I  H函数用法：
[Xn,Xps]=mapminmax(X,min,max)
6 h  B+ w. K' o+ T- b$ g, A& l. P* R+ G1 q
说明：（1）该函数将X按行归一化，即计算某元素的归一化值时，最大最小值时该元素所处行的最大最小值；因此若只有一组观测时，X需是1*N的行向量。

7 {& u, G  x1 E' I! s　　　（2）min,max规定X的归一化范围，根据需要自行设置

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

　调用方法：
6 U) I2 ~; t! Q0 m0 ~" J; M: y
X1=mapminmax('apply', X_new,Xps);%利用先前的结构Xps进行相同的归一化
% G& O; ]9 _$ B$ ?
X2=mapminmax('reverse',Xn, Xps);%反归一化

x=[1,-1,2;　　　2,0,0;　　　0,1,-1]
[x1,Xps]=mapminmax(x,0,1)
# a4 @. c/ B9 Q" A' s
2 z' A8 z; i/ o
+ _( x2 \4 x8 d8 X
3 t" f5 ]4 e) I- ]' \7 v1 ~# |/ G: @1 u对于python中的axis=0 和axis=1的问题
( W- ?- ]2 B8 R6 y4 | 如df.mean其实是在每一行上取所有列的均值，而不是保留每一列的均值。也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词（译者注）
% {) f, f: Y! P- d换句话说:
) E/ W# v* g7 {1 Y
$ u( F4 v5 q1 P' d" L使用0值表示沿着每一列或行标签\索引值向下执行方法
# p6 a5 Z* W6 Y/ J' W使用1值表示沿着每一行或者列标签模向执行对应的方法

7 m5 z5 k' T; a& X- o# G
$ l* F+ y8 m+ d
python的sklearn中 scale函数
( k: i' |9 E6 F3 r  h& s5 J1 标准化，均值去除和按方差比例缩放
              （Standardization, or mean removal and variance scaling）
# N. B# F: B5 C
5 U+ P/ _+ Q: [" u, `4 x  m　　数据集的标准化：当个体特征太过或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。
) j1 ~3 |1 G" D( f3 r! G
from sklearn import preprocessing
import numpy as np  
X = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
1 @+ Z2 L3 t! [X_scaled = preprocessing.scale(X)
& {/ f, X7 y- p% I3 ~
- N/ ]' d4 a, K+ A& C. p#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
                                 [ 1.22474487  0.         -0.26726124]
0 N8 Z' H6 t3 [                                  [-1.22474487  1.22474487 -1.06904497]]
＃scaled之后的数据列为零均值，单位方差
8 C2 }0 W- T. z/ X  kX_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
X_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])



StandardScaler
Standardization即标准化，StandardScaler的归一化方式是用每个特征减去列均值，再除以列标准差。归一化后，矩阵每列的均值为0，标准差为1，形如标准正态分布（高斯分布）。 通过计算训练集的平均值和标准差，以便测试数据集使用相同的变换。（在numpy中，有std()函数用于计算标准差）

) R) B: [& P+ X; U4 K2 n  K) o  dfrom sklearn.preprocessing import StandardScaler
x=[[10001,2],[16020,4],[12008,6],[13131,8]]
X_scaler = StandardScaler()
X_train = X_scaler.fit_transform(x)
X_train
/ b' `" F1 O- n# w#结果如下
array([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
! H9 E5 C2 G; u6 }5 @1 F       [-0.35938143,  0.4472136 ],
       [ 0.15671236,  1.34164079]])
; L3 m# }. ^+ H0 T% _
7 q( F, T9 O4 I4 O# X

注 ：

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

from sklearn.preprocessing import StandardScaler
8 h5 r/ E) t: {! c0 Xx=[[10001,2],[16020,4],[12008,6],[13131,8]]
$ b' V4 d; [- c& X; pX_scaler = StandardScaler()
# Q3 g* C  p, ^& `X_train = X_scaler.fit_transform(x)
X_train
#结果如下
6 {1 ?$ \, b: Warray([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
       [-0.35938143,  0.4472136 ],
2 ~/ ~. \  ~4 C6 I7 k       [ 0.15671236,  1.34164079]])

scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
- o" @7 J9 c) e+ w# i" @) c% p, gscaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
scaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913])
#测试将该scaler用于输入数据，变换之后得到的结果同上
scaler.transform(X)
#out:
array([[ 0., -1.22474487,  1.33630621],
       [ 1.22474487, 0. , -0.26726124],
8 |0 T/ V. l# Q- b$ L       [-1.22474487,1.22474487, -1.06904497]])  
scaler.transform([[-1., 1., 0.]])  #scale the new data
( s9 g: g& y& i1 b# out: array([[-2.44948974,  1.22474487, -0.26726124]])

2 `5 f3 f* s5 M) l. a; D6 w+ z8 |2 将数据特征缩放至某一范围(scalingfeatures to a range)


' c& W7 |8 F' b5 d( g' l+ d2.1 MinMaxScaler (最小最大值标准化)
" j6 i5 ~: K9 ~2 G4 D 它默认将每种特征的值都归一化到[0，1]之间，归一化后的数值大小范围是可调的（根据MinMaxScaler的参数feature_range调整）。  
, [- Z6 }! U2 }6 S
! b0 o) P- ]% y' s# T: p* ffrom sklearn.preprocessing import MinMaxScaler
x=[[10001,2],[16020,4],[12008,6],[13131,8]]
' V1 v: u2 d% o* Lmin_max_scaler = MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(x) #归一化后的结果，
8 E! C; ^; M( ^5 E' M7 |  v2 v
5 z  ]4 H9 u. cmin_max_scaler = MinMaxScaler(feature_range=(-1,1))
X_train_minmax = min_max_scaler.fit_transform(x) #归一化到(-1,1)上的结果

MinMaxScaler的实现
4 u1 V- B& x8 T' z# w' p! \/ c& tX_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
8 E% s' T! T7 R/ j4 LX_scaled = X_std / (max - min) + min
' p! r+ X2 q& ^5 z+ Y4 `; R3 n
1 Z3 p4 E0 \& \2 P/ k! v这是 向量化的表达方式，说明X是矩阵，其中

  ~. E- K4 t5 k1 `- aX_std：将X归一化到[0，1]之间
X.min(axis=0)表示列最小值
max，min表示MinMaxScaler的参数feature_range参数。即最终结果的大小范围

/ y' `3 _5 e  k
2 N% n7 f; m  d/ ^$ e2.2 MaxAbsScaler（绝对值最大标准化）
+ N0 Q  A) p: E4 B; S         与上述标准化方法相似，但是它通过除以最大值将训练集缩放至[-1,1]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据。
/ ^) J: Z. ?0 D
( `4 C! n/ z  ?/ i3 ~# N2 ]+ g: YX_train = np.array([[ 1., -1.,  2.],
                     [ 2.,  0.,  0.],
/ q) B3 I5 v0 m' E& ?5 F                    [ 0.,  1., -1.]])
max_abs_scaler = preprocessing.MaxAbsScaler()
X_train_maxabs = max_abs_scaler.fit_transform(X_train)
# doctest +NORMALIZE_WHITESPACE^, out: array([[ 0.5, -1.,  1. ], [ 1. , 0. ,  0. ],       [ 0. ,  1. , -0.5]])
# }3 d9 w/ \8 o5 F/ JX_test = np.array([[ -3., -1.,  4.]])
) D( j* S7 l2 j- }X_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
+ M; ?% f$ k4 F' ~  Amax_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])

9 ^  T9 @$ c  ]4 x




4 [& I3 |8 @3 S; w

$ v. L8 d8 u- b! ^) l5 P, R4 C

————————————————
版权声明：本文为CSDN博主「wamg潇潇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_29831163/article/details/89420223

. u8 j. |# c" v% n  ?* |