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

浅夏110

特征归一化，又叫 特征缩放，Feature Normalization，Feature Scaling。各特征由于数值大小范围不一致，通过缩放特征的取值范围，可以消除量纲，使特征具有可比性。只有各特征之间的大小范围一致，才能使用距离度量等算法，加速梯度下降算法的收敛；在SVM算法中，一致化的特征能加速寻找支持向量的时间；不同的机器学习算法，能接受的输入数值范围不一样。sklearn中最常用的特征归一化方法是MinMaxScaler和StandardScaler。
$ w' o9 B2 l+ L6 G8 ^9 A
当我们需要将特征值都归一化为某个范围[a,b]时，选 MinMaxScaler
当我们需要归一化后的特征值均值为0，标准差为1，选 StandardScaler
数据变换的目的：
) k3 a; h& V8 a  对收集来的原始数据必须进行数据变换和处理，主要是为了消除量纲，使其具有可比性。

6 Z3 x! o& u7 `. k 定义 ： 设有n个数据的序列  ，则称映射
* M! r0 [$ J( Y7 z/ |& N! ~
7 {* O5 j( y$ F: y& R                                       

          为序列 x到序列 y 的数据变换。
4 _4 `2 U' T" }, Z! Q
数据变换的七种常见方式
此处是对同一维度上的各个数据进行变换，如果数据有多个维度/属性，那就拆开来一个属性属性地变换，写成矩阵形式时，它也是分别对各维度进行操作。

$ k. _+ t5 B4 \3 `: ^初值化变换
/ u8 h% p$ |: ]1 }5 B+ v$ s7 i
: U  K4 w! n+ @/ J1 W
6 I0 P9 a" e  [ 也就是要对每一个数据，都除以第一个数据。

均值化变换

4 c4 |; s6 Q" N7 U: T
             对每一个数据，都除以均值。
7 U5 t! x0 P# ^' U; f
- t2 m5 e) }* _4 a! d百分比变换
. X3 P+ g' w' O5 D7 `5 `

分母为x的该列属性中，值最大的那一个，使得变换后的值的绝对值，在[0,1]之间。

倍数变换
   
  L2 E: ?6 K) P- Q' l9 r  }: u
归一化变换
8 `. s" D1 [  |& t' S. L
5 H) i7 m; Z7 H+ G2 G
, W) |$ l0 v& i 其中   为大于零的某个值，称  是归一化变换。


# R4 r% y( `3 ~5 B极差最大值化变换
) B. z& }* W6 Y$ l* `. L
( t4 ^1 H' t/ {. m9 l
" ]$ m8 x/ P0 n2 v7 X
1 f/ m2 e& N2 p7 }5 j
0 w2 u* Q3 @" B& E区间值化变换
$ e; `5 A7 `" `& @
8 Y) n. V# q  N
                  ,
& G/ J6 g! ?. A+ }
2 f; t* Q5 D* i1. matlab 的mapminmax归一化函数
6 G5 H6 E4 {3 N8 R4 q函数用法：
[Xn,Xps]=mapminmax(X,min,max)

$ a5 T3 Q4 G  o. ]9 O说明：（1）该函数将X按行归一化，即计算某元素的归一化值时，最大最小值时该元素所处行的最大最小值；因此若只有一组观测时，X需是1*N的行向量。
0 _3 I3 E" t% E8 ~  F3 E
　　　（2）min,max规定X的归一化范围，根据需要自行设置
9 b+ }1 {$ S; i! k1 ]
* M% L3 [% d( u# W6 s9 W! x　　　（3）ps是结构变量记录了归一化时的最大值最小值等参数，后续可重复调用　　　　　
2 ?& I3 U+ R3 y2 {, ]- Q) e& @
, q. _4 E) k2 h4 U- e! }% R! C8 u　调用方法：
. T$ h1 b1 a/ S
X1=mapminmax('apply', X_new,Xps);%利用先前的结构Xps进行相同的归一化
& R( ?& q. o6 g  g& ^
, {0 O) ?% ?- P- t: Y( [/ G) ^$ FX2=mapminmax('reverse',Xn, Xps);%反归一化

x=[1,-1,2;　　　2,0,0;　　　0,1,-1]
[x1,Xps]=mapminmax(x,0,1)



' ?+ K0 X1 L1 }$ i7 C- i对于python中的axis=0 和axis=1的问题
; ^1 Z! \: n# b 如df.mean其实是在每一行上取所有列的均值，而不是保留每一列的均值。也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词（译者注）
! g, \5 C1 G$ M" B- [/ K3 s换句话说:

使用0值表示沿着每一列或行标签\索引值向下执行方法
$ L9 R/ Y; d8 J5 n' H1 ~$ C使用1值表示沿着每一行或者列标签模向执行对应的方法
# q" W( z) I$ k/ A- o* e


python的sklearn中 scale函数
9 Q; a: g7 {2 O1 标准化，均值去除和按方差比例缩放
% m- m. `& q- ?5 b8 T( R% h              （Standardization, or mean removal and variance scaling）
& r" u) M# D. I# J; g8 v
　　数据集的标准化：当个体特征太过或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。

: P! `- y  _* n  yfrom sklearn import preprocessing
7 P; }% \: ~1 `4 h  U5 v+ }import numpy as np  
X = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
% b& Z7 Z2 P; B5 e5 u  p6 \* DX_scaled = preprocessing.scale(X)
6 G$ H( y& {  y
#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
                                 [ 1.22474487  0.         -0.26726124]
                                 [-1.22474487  1.22474487 -1.06904497]]
2 B4 ~* I2 w0 b+ N7 |- O＃scaled之后的数据列为零均值，单位方差
) L' ~1 m7 T7 ~8 GX_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
X_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])
- B$ h# k' W7 {! {6 p# ~

+ E; q- N" x0 |0 H6 Y
StandardScaler
& K& N1 ]( ], W: ~# [Standardization即标准化，StandardScaler的归一化方式是用每个特征减去列均值，再除以列标准差。归一化后，矩阵每列的均值为0，标准差为1，形如标准正态分布（高斯分布）。 通过计算训练集的平均值和标准差，以便测试数据集使用相同的变换。（在numpy中，有std()函数用于计算标准差）
1 e5 f, a2 ?( x- k* _( ^
from sklearn.preprocessing import StandardScaler
x=[[10001,2],[16020,4],[12008,6],[13131,8]]
4 E1 Z/ V( v+ P4 W: _' zX_scaler = StandardScaler()
' d1 u) y7 o# r( H, m3 FX_train = X_scaler.fit_transform(x)
7 }4 W/ b. x; X2 HX_train
#结果如下
array([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
: x9 B& }0 f) z: I       [-0.35938143,  0.4472136 ],
       [ 0.15671236,  1.34164079]])


' a. @! T- Z. y+ c6 S3 R* `

注 ：

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

from sklearn.preprocessing import StandardScaler
* B, y7 V  g2 A+ H& ~x=[[10001,2],[16020,4],[12008,6],[13131,8]]
/ [( U* m6 ^8 ]* FX_scaler = StandardScaler()
8 e/ m4 |$ `: d! b5 F0 _' H6 t0 UX_train = X_scaler.fit_transform(x)
  s6 k8 t5 g6 ^4 p- ^0 T/ @X_train
4 A( T1 [* M; F# P8 [, q. s#结果如下
# v2 @, @$ o! Z( A5 C' Harray([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
1 Y) A3 u( a  M       [-0.35938143,  0.4472136 ],
       [ 0.15671236,  1.34164079]])
4 @1 O6 Z* L7 n- M' \* _$ o
scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
2 ]- |$ h9 J6 Lscaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
scaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913])
6 L) o" v4 s- }; O" C$ F1 B9 }' q% u#测试将该scaler用于输入数据，变换之后得到的结果同上
scaler.transform(X)
/ T1 O& v5 z3 l" i+ N: c#out:
% y& v6 Z6 z% W9 A- Q6 [array([[ 0., -1.22474487,  1.33630621],
       [ 1.22474487, 0. , -0.26726124],
2 ], _' \: d3 k# F( \7 j8 a) l       [-1.22474487,1.22474487, -1.06904497]])  
scaler.transform([[-1., 1., 0.]])  #scale the new data
# out: array([[-2.44948974,  1.22474487, -0.26726124]])

0 g9 V9 ?6 B  e( N) A) h9 ^7 M2 将数据特征缩放至某一范围(scalingfeatures to a range)

/ |6 Y3 M- v; w/ i
2.1 MinMaxScaler (最小最大值标准化)
3 a7 ^3 n. d0 p1 | 它默认将每种特征的值都归一化到[0，1]之间，归一化后的数值大小范围是可调的（根据MinMaxScaler的参数feature_range调整）。  

from sklearn.preprocessing import MinMaxScaler
/ p* I1 W2 W) w$ N# fx=[[10001,2],[16020,4],[12008,6],[13131,8]]
min_max_scaler = MinMaxScaler()
X_train_minmax = min_max_scaler.fit_transform(x) #归一化后的结果，

min_max_scaler = MinMaxScaler(feature_range=(-1,1))
" r  P( e7 N* C' T$ AX_train_minmax = min_max_scaler.fit_transform(x) #归一化到(-1,1)上的结果
7 V  h- C0 L4 \! P! B
MinMaxScaler的实现
X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std / (max - min) + min
* h- N, ~: x# E" L& K3 L5 x
* e& Y& {6 Q6 c' X, T) `" k# A这是 向量化的表达方式，说明X是矩阵，其中
* C' Z0 l/ F) l2 B8 Q
X_std：将X归一化到[0，1]之间
' C0 M; ]7 i: J+ k) e1 [X.min(axis=0)表示列最小值
/ m# t2 @% p9 C- T  ]. Lmax，min表示MinMaxScaler的参数feature_range参数。即最终结果的大小范围

, [5 ^; p/ K5 x' F; i# S
2 q- [% Q; p, ]  P# l. t; V2.2 MaxAbsScaler（绝对值最大标准化）
         与上述标准化方法相似，但是它通过除以最大值将训练集缩放至[-1,1]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据。

X_train = np.array([[ 1., -1.,  2.],
                     [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
7 V3 z% `* N8 ~% R: wmax_abs_scaler = preprocessing.MaxAbsScaler()
! r% ^" b9 }5 ^) ~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]])
" M! j) b+ B: D( u2 [X_test = np.array([[ -3., -1.,  4.]])
* O9 u6 Z  Y+ O: n. Z. E( ?8 VX_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
( S' B9 @% k2 q  J  p* I8 Pmax_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])
$ a* j- V# c% |1 M
( W# J+ k* T; r8 N

2 H: \- T3 x( Z
0 b1 i9 v/ o& ?8 h



$ p: Y" m- G' C

————————————————
版权声明：本文为CSDN博主「wamg潇潇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
5 E. a, i) ]: L8 J( `% J% e原文链接：https://blog.csdn.net/qq_29831163/article/details/89420223
& c4 g" n5 }  {: X3 e6 [
& K% @* }( X* l