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

浅夏110

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

当我们需要将特征值都归一化为某个范围[a,b]时，选 MinMaxScaler
% y+ N# m. m6 G# I3 l当我们需要归一化后的特征值均值为0，标准差为1，选 StandardScaler
数据变换的目的：
  对收集来的原始数据必须进行数据变换和处理，主要是为了消除量纲，使其具有可比性。

$ u* y; K) p, D! z5 b( H 定义 ： 设有n个数据的序列  ，则称映射

+ M% h# c# q# K                                       

; i6 j7 n+ H5 c8 c. ^7 y% I* H: S          为序列 x到序列 y 的数据变换。
  Y: i4 L' W5 ]5 X# K6 ~( B
  o9 Y, [$ \0 g数据变换的七种常见方式
! ~6 \$ r; }7 G; u此处是对同一维度上的各个数据进行变换，如果数据有多个维度/属性，那就拆开来一个属性属性地变换，写成矩阵形式时，它也是分别对各维度进行操作。
; {- a2 \+ ^- P. }) x. N* \
初值化变换
. P0 Y- s. D( _2 G& @) i0 |

也就是要对每一个数据，都除以第一个数据。
8 h: G2 }4 j2 }; k
$ ?+ ]8 t8 X8 [5 |$ i& v均值化变换

5 Y) u- h5 |* f4 I/ [% U. J
/ k: h+ L  A+ b) |; f% I             对每一个数据，都除以均值。
6 s/ Z# v8 v! u* {! T- U$ {8 e
百分比变换


! g; X8 m3 X. y# d1 b; D7 R; _分母为x的该列属性中，值最大的那一个，使得变换后的值的绝对值，在[0,1]之间。
$ z1 q$ v# B4 v& p- r
倍数变换
* N' S: u( b* R; a   
8 F; _" I. B: i. Y, `: T0 h
归一化变换


其中   为大于零的某个值，称  是归一化变换。
$ t9 |4 {* X9 C! z, T
. j) B6 _  Y9 a4 r
* y3 l+ o6 j! d- A极差最大值化变换




! D! {8 c4 v6 }. e& g- u9 ~6 X区间值化变换


' B! }: E1 a3 m" B- N- V0 D                  ,
$ t" g% u* |7 p; Q/ A7 {
1. matlab 的mapminmax归一化函数
- p! [- G$ j4 I5 ?4 f' H函数用法：
: z! {' T! a4 ^9 f [Xn,Xps]=mapminmax(X,min,max)
  u  U  V1 R; v) u; h) P$ S
说明：（1）该函数将X按行归一化，即计算某元素的归一化值时，最大最小值时该元素所处行的最大最小值；因此若只有一组观测时，X需是1*N的行向量。

" S, [% x  f+ i7 ~　　　（2）min,max规定X的归一化范围，根据需要自行设置

　　　（3）ps是结构变量记录了归一化时的最大值最小值等参数，后续可重复调用　　　　　
$ v% W# q2 w7 C' w# ?/ V9 w/ z$ a
! X2 l9 R/ D/ ]2 K) g: s; r  Q　调用方法：
* ^3 _3 s' S  r# c# K. d. I
/ v0 t8 o& ]: A& ^X1=mapminmax('apply', X_new,Xps);%利用先前的结构Xps进行相同的归一化
8 ^" b4 V2 n1 [* Y5 V
X2=mapminmax('reverse',Xn, Xps);%反归一化

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

6 P; N0 m  X9 Y  Y3 h# k+ |* {) f

( a1 a( T9 W; p/ ~/ B- n对于python中的axis=0 和axis=1的问题
如df.mean其实是在每一行上取所有列的均值，而不是保留每一列的均值。也许简单的来记就是axis=0代表往跨行（down)，而axis=1代表跨列（across)，作为方法动作的副词（译者注）
5 t) B+ a# a/ @6 I% P# m6 n. f换句话说:
4 U! B; z  r5 _! D+ w; g0 a
使用0值表示沿着每一列或行标签\索引值向下执行方法
% ]" y/ X' H  V" \8 @& p使用1值表示沿着每一行或者列标签模向执行对应的方法
% Q. Y" v2 E  [. n0 z& U; p

. D( W; U4 B- {6 k) R$ }
2 e1 l% n% ]1 U- Z8 tpython的sklearn中 scale函数
1 标准化，均值去除和按方差比例缩放
8 k8 q$ j" G' j/ J4 H              （Standardization, or mean removal and variance scaling）
. ~, C& t* ]$ J; I0 G6 F) L
　　数据集的标准化：当个体特征太过或明显不遵从高斯正态分布时，标准化表现的效果较差。实际操作中，经常忽略特征数据的分布形状，移除每个特征均值，划分离散特征的标准差，从而等级化，进而实现数据中心化。
* A5 m0 `6 ^% X, p- d$ U
from sklearn import preprocessing
2 _1 D+ }- H# B" ?) |: B- j: Vimport numpy as np  
X = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]])  
' ]" \4 F% o# y9 ]X_scaled = preprocessing.scale(X)

4 Y/ r0 x2 C  ?/ h; C' \# {% _#output :X_scaled = [[ 0.         -1.22474487  1.33630621]
                                 [ 1.22474487  0.         -0.26726124]
                                 [-1.22474487  1.22474487 -1.06904497]]
( T% M6 I( }- E2 \＃scaled之后的数据列为零均值，单位方差
4 @3 U/ K% N1 u. h  _/ y9 r% ^& cX_scaled.mean(axis=0)  # column mean: array([ 0.,  0.,  0.])  
; D( o' R, t, k  A8 {6 d* d" S3 W8 HX_scaled.std(axis=0)  #column standard deviation: array([ 1.,  1.,  1.])
8 a3 Y# h  U! y6 K/ _
+ h' r2 F" {. ~1 _: b5 H: c
. g8 V  J3 |' e% o) n( y: ~
4 E! T" p  Q0 Q9 n- g( PStandardScaler
7 R0 z- u: }  K5 zStandardization即标准化，StandardScaler的归一化方式是用每个特征减去列均值，再除以列标准差。归一化后，矩阵每列的均值为0，标准差为1，形如标准正态分布（高斯分布）。 通过计算训练集的平均值和标准差，以便测试数据集使用相同的变换。（在numpy中，有std()函数用于计算标准差）

from sklearn.preprocessing import StandardScaler
x=[[10001,2],[16020,4],[12008,6],[13131,8]]
X_scaler = StandardScaler()
X_train = X_scaler.fit_transform(x)
) e" V6 Y; M# a# c! g( j' d3 JX_train
3 M+ `: G5 n6 G0 x#结果如下
- u/ z5 j8 s1 w* U- Warray([[-1.2817325 , -1.34164079],
' f4 u5 B4 u9 P       [ 1.48440157, -0.4472136 ],
+ ^4 d# T! O$ `% n: e7 Q       [-0.35938143,  0.4472136 ],
, ^( Y; L- {; }! i) o  _! f       [ 0.15671236,  1.34164079]])
, X# o! C1 ?. y, s( J2 v- L8 X
1 f3 J& S* x3 ]3 I. d& }# h& n

注 ：

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

from sklearn.preprocessing import StandardScaler
! J; z9 U- w% g$ Sx=[[10001,2],[16020,4],[12008,6],[13131,8]]
& \; L( s+ Z, p- l0 RX_scaler = StandardScaler()
, Y# S% B1 g. R; a+ ?: Q& SX_train = X_scaler.fit_transform(x)
X_train
#结果如下
. w( e  M6 T) a; U6 Earray([[-1.2817325 , -1.34164079],
       [ 1.48440157, -0.4472136 ],
1 R  F! O  g% k  u( U' B' O& G       [-0.35938143,  0.4472136 ],
' U! [6 \( V* m4 U" i       [ 0.15671236,  1.34164079]])
, u0 i# v( K* ^5 R4 |% q: D  _% D
scaler = preprocessing.StandardScaler().fit(X) #out: StandardScaler(copy=True, with_mean=True, with_std=True)
) z& j/ P; U3 H5 D# L0 ~% Q2 J5 jscaler.mean_  #out: array([ 1.,  0. ,  0.33333333])  
scaler.std_ #out: array([ 0.81649658,  0.81649658,  1.24721913])
#测试将该scaler用于输入数据，变换之后得到的结果同上
  _6 J' m% c6 O& s3 ~/ hscaler.transform(X)
#out:
/ o. u" w+ i! o  parray([[ 0., -1.22474487,  1.33630621],
       [ 1.22474487, 0. , -0.26726124],
       [-1.22474487,1.22474487, -1.06904497]])  
8 a4 i& U. @0 [& q: qscaler.transform([[-1., 1., 0.]])  #scale the new data
5 Y8 O% Z- {2 e) W- a# out: array([[-2.44948974,  1.22474487, -0.26726124]])

' E: m7 s* ^. n  C. {  Z2 将数据特征缩放至某一范围(scalingfeatures to a range)


4 X. h: X, v7 n$ h# W9 X2.1 MinMaxScaler (最小最大值标准化)
它默认将每种特征的值都归一化到[0，1]之间，归一化后的数值大小范围是可调的（根据MinMaxScaler的参数feature_range调整）。  
+ H) P* |0 I6 Y; g  S3 P; u
from sklearn.preprocessing import MinMaxScaler
* K2 x5 m0 E3 Y9 _9 Q# d% S& Ax=[[10001,2],[16020,4],[12008,6],[13131,8]]
min_max_scaler = MinMaxScaler()
3 @) b1 U6 K9 o+ W/ ?( YX_train_minmax = min_max_scaler.fit_transform(x) #归一化后的结果，

; `! a2 F! T2 K4 \% Bmin_max_scaler = MinMaxScaler(feature_range=(-1,1))
) }2 M+ J7 i' j, e3 u, O- MX_train_minmax = min_max_scaler.fit_transform(x) #归一化到(-1,1)上的结果
  z0 n) b/ T' a0 l7 Z0 w
3 c  I. p8 o! n. L4 BMinMaxScaler的实现
" l* D! s( d+ qX_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std / (max - min) + min

( Y. r, z1 P& n5 y这是 向量化的表达方式，说明X是矩阵，其中
4 t* M) T  p! g5 {4 l: i$ j0 ~8 a
3 U" T$ D; C+ F8 ?5 oX_std：将X归一化到[0，1]之间
2 y& l. c+ T. A  q: Z1 h; \X.min(axis=0)表示列最小值
max，min表示MinMaxScaler的参数feature_range参数。即最终结果的大小范围


9 ]9 a5 c% F) W" D) V' R. s2.2 MaxAbsScaler（绝对值最大标准化）
8 b7 L6 _+ N% s+ P9 b1 Q9 v         与上述标准化方法相似，但是它通过除以最大值将训练集缩放至[-1,1]。这意味着数据已经以０为中心或者是含有非常非常多０的稀疏数据。

X_train = np.array([[ 1., -1.,  2.],
                     [ 2.,  0.,  0.],
                    [ 0.,  1., -1.]])
0 |- k; q1 M: C( [max_abs_scaler = preprocessing.MaxAbsScaler()
+ i( o6 H1 T; f* n7 N6 MX_train_maxabs = max_abs_scaler.fit_transform(X_train)
. \4 p" x9 g$ r) v( n' l* V# doctest +NORMALIZE_WHITESPACE^, out: array([[ 0.5, -1.,  1. ], [ 1. , 0. ,  0. ],       [ 0. ,  1. , -0.5]])
9 Q% c$ q0 P6 |3 l' ]6 JX_test = np.array([[ -3., -1.,  4.]])
X_test_maxabs = max_abs_scaler.transform(X_test) #out: array([[-1.5, -1. ,  2. ]])
max_abs_scaler.scale_  #out: array([ 2.,  1.,  2.])







, c6 n" l/ V5 u; b


& D( v3 X5 D7 V; n% P( e- W& A————————————————
版权声明：本文为CSDN博主「wamg潇潇」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
5 x' |) U/ U. E) w/ o/ z+ e% {9 `* L, s原文链接：https://blog.csdn.net/qq_29831163/article/details/89420223
- w; ]2 K8 K9 i/ x0 W9 z9 ?' k
1 |/ I) V. O/ y3 Q