|
9 N `1 d. e! B! ^9 `; {) k) B1 V. y sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
7 w& i K) ]& l7 q2 B' E, U% m 归一化是标准化的一种方式,
% R0 l$ d8 P& n+ E, Y" m 归一化是将数据映射到[0,1]这个区间中,
- r% V2 \+ h( ?3 q: \% E! h 标准化是将数据按照比例缩放,使之放到一个特定区间中, 9 x9 x& E( _8 [
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. / S/ j5 y z/ d. N/ W6 g. @
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
6 O: T) f; K5 `% T2 @0 J* I& J- E 导入模块:
) b% j8 H" b) m7 E& L from sklearn.preprocessing import StandardScaler! w/ W- G0 T T, g6 E
from sklearn.preprocessing import MinMaxScaler
/ U4 ~6 @; {4 [ Y ~4 I7 q2 x from matplotlib improt gridspec, N1 R; S% ~6 }1 c' ^
import numpy as np
5 }, e, T7 Q; ^ import matpotlib.pyplot as plt 1 O' f, a0 w, ?) j/ E2 C/ M
使用sklearn 进行标准化和标准化还原
# V" c; |, T8 x 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
4 K% ~6 }" P+ g5 f! _4 n/ E+ ` std = StandardScaler()! s/ `9 P& h, j- M
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
) E9 l% d" p" j9 U2 W
$ K# W: ^4 v! w # 将标准化后的数据转换为原始数据。
|% o, h" F% a, k. O std.inverse_transform()
; ~' C7 [: e" F7 [. @% N+ Y 查看标准化后的数据的均值与方差
% W+ P K g+ l( m9 D% U/ {8 p x_scale.mean(axis=0)# 均值
. |* E$ j ~& z, }7 B; M) V1 X # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
: w" c: t7 I4 p/ t+ ] x_scale.mean(axis=1) - x3 u" y- E: `( n( O3 _6 u
`
. O3 _# u& E$ _+ w1 K" \ cps = np.random.random_integers(0, 100, (100, 2)): \, r9 V& R, z" z$ V( |" K
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.$ M7 ?0 f+ Z* c/ y. g
ss = StandardScaler()
+ E' ?- K- p8 j* Q" r, v: B std_cps = ss.fit_transform(cps)
2 T$ o2 x, p( w" i, B gs = gridspec.GridSpec(5,5)6 ]+ M3 k* X7 y
fig = plt.figure()
( r9 a }* v8 u5 [ ax1 = fig.add_subplot(gs[0:2, 1:4])+ ]0 K2 {) s+ G0 l
ax2 = fig.add_subplot(gs[3:5, 1:4])
7 G: J( s9 F4 E" j' }, Q ax1.scatter(cps[:, 0], cps[:, 1])- C/ _: t; w8 m; p8 O( t2 h
ax2.scatter(std_cps[:, 0], std_cps[:, 1])& b$ V4 O: ?* A
plt.show()
! |& a" E+ j; Y l6 T& j. L ` 5 D7 x9 y& x) H: ^. c
from sklearn.preprocessing import StandardScaler
; O2 N5 j7 z/ }, x) |! S& k9 @8 M from sklearn.preprocessing import MinMaxScaler' Q, J5 b) T. G4 l+ o/ g$ h+ d
from matplotlib import gridspec% {$ P Y1 }9 i7 E R
import numpy as np- p8 @' ]0 ?! F: i, f- ~
import matplotlib.pyplot as plt! p& p) R+ ]/ F' H
data = np.random.uniform(0, 100, 10)[:, np.newaxis]- C# ]- Y. |: T0 d8 e
ss = StandardScaler() Z8 Z+ B$ Z# k' k
std_data = ss.fit_transform(data)
3 F$ H6 T! p# O7 r ^! E origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
+ F% I. p. }3 [& g: S1 y% P: I* x* m7 ` print(data is 原始数据,data)
$ y g: u% p2 V6 g6 H+ ^, H& v' W. Z! u print(after standard 标准化后的数据,std_data)
4 p( N+ E" x: |* K3 Y [+ G print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data): R0 B7 K! N+ L! ~( p3 T
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
$ ~$ E* L3 ~+ s. @' o/ y3 D 使用sklearn 进行数据的归一化和归一化还原.
, b) S6 ^* i2 @8 \ data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
: W3 e' ~3 }8 H$ x3 Y& q mm = MinMaxScaler()# 创建MinMaxScaler 对象
/ L0 u2 L0 t# ]/ D2 P mm_data = mm.fit_transform(data) # 归一化数据! S# b5 [7 m. }( l+ A
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据. a k4 x1 _# V* h3 [
print(data is ,data)% V" L0 K, H4 g: K7 ~
print(after Min Max ,mm_data)
( @- l8 k2 r. s+ ] print(origin data is ,origin_data)
2 }- c/ ]! b' G' J! l/ Q1 U6 H8 ~ MinMaxScaler和MaxAbsCaler:8 M5 n, K1 [# h5 {; W, V! y# E* D- K& F
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) 7 ]& n% ]/ K g# G* c, k& m
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
' m1 z8 K- O+ d) v# B/ U T min_max_scaler = preprocessing.MinMaxScaler()
0 s( b. Y" a* k1 y$ u# J" o& v x_minmax = min_max_scaler.fit_transform(x)7 j- F/ M' |3 `# m% Q
x_minmax
3 z" O* j) t- `) g; w) H" [$ c K 对于新进来的数据,采用如下方式进行函数调用:
1 e. d; F$ |% D7 \2 \ x_test = np.array([[-3., -1., 4.]])9 w: i: l0 K- Y2 Z
x_test_minmax = min_max_scaler.transform(x_test)
+ O" Q3 `; w* h _8 W0 P R x_test_minmax ) v/ t+ Q8 k. y m
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
$ _6 F1 E/ ]- l) X1 b max_abs_scaler = preprocessing.MaxAbsScaler()
' R4 m' Z/ B' D! B, ?2 O7 W6 X% J6 R x_train_maxsbs = max_abs_scaler.fit_transform(x)
) g# @, u1 c8 z5 q! n% F5 B x_train_maxsbs
6 g* y& l- i* R3 |8 o) V # 同理，也可以对新的数据集进行同样的转换 * S& j. ~+ l# G$ U, t) B2 q
x_test = np.array([[-3., -1., 4.]])
( Z4 m$ o# W$ b8 G: j( }- \ x_test_maxabs = max_abs_scaler.transform(x_test)
2 R2 h/ E! ^4 w$ V x_test_maxabs
/ P6 I' H8 @! @3 r/ w* e 针对规模化稀疏数据
& t5 B5 H1 y. R 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
( u0 n; X: ` c9 g: G* i MaxAbsScaler,和maxabs_scale
$ m( k! D: k" s \3 {/ T3 {! }: r 针对规模化有异常的数据
( ?0 M3 {) w) C$ W# d$ Z4 g& z 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
, n9 f& }+ h& A L 正则化Normalization, { s8 F/ m8 a
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
p# ^: a/ K, d/ |9 d# X x_normalized = preprocessing.normalize(x, norm=l2) k. R% M" Q, K6 a
print x ?' |% u8 _( K
print x_normalized . S! l: b% I5 X# [- @- b( a* z
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
- b1 S* a& N- Z. Y3 G, k0 ? normalizer = preprocessing.Normalizer().fit(x)# V- ~$ y8 h& }; U+ V( e8 b. z
normalizer
2 d- s' d0 l% P$ J7 W" u+ P# o' ~ # 对训练数据进行正则 9 U7 u5 ~7 b9 E3 K+ D
normalizer.transform(x) 2 X/ e7 r( R; P3 T+ y* P
# 对新的测试数据进行正则
5 E. S: K( b+ R7 R7 T- i normalizer.transform([[-1., 1., 0.]]) 5 m% J; ^2 H$ _9 p( K" w+ ?0 ?/ u0 X
二值化
. j. @/ Y, A, D. ^0 i 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 # Q9 c% w, `- M7 t% s
from sklearn import preprocessing
/ l1 B# E0 Y& H* @ F4 G' f import numpy as np
# ]7 O# M6 Q- f7 W# D( e/ a; ]2 J8 S3 P
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征0 C$ e* y) f0 {- X! G+ Y# |
x = np.array([[1., -1., 2.],3 U$ s3 ?9 Z+ _% m$ P
[2., 0., 0.],
; r$ K: l+ g" Z: F' n [0., 1., -1.]])+ v0 M, _- K. o7 d R
5 G* L( a. r1 H binarizer = preprocessing.Binarizer().fit(x)
, j: i1 ^( `! I- S' k+ z( S binarizer.transform(x)
+ u- h. L3 J# r$ v+ E; @7 T& ?5 F$ v8 _
binarizer = preprocessing.Binarizer(threshold=1.5)
" C! [! B# Q6 Y binarizer.transform(x)
9 m' q6 t5 w+ M3 I+ U3 C. A 为类别特征编码9 X6 k/ z; U3 V- I* g( o5 Y# d
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. 4 p9 Y4 I9 S+ b. c' C* O ^7 Z
OneHotEncoder ! g' Q+ _4 {2 s7 M3 j; f. b
弥补缺失数据
9 F8 u# b& M/ c" C4 b( y 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. , a0 T* \ C8 P" N% C
import numpy as np. \0 C! N: o2 M1 @+ L( e
from sklearn.preprocessing import Imputer
' ]3 V. ]# \$ B/ ^4 w0 w imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
. ?* [2 n& u4 ?% | imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
: I. {9 z; F; ]" X% c+ v x = [[np.nan, 2], [6, np.nan], [7, 6]]
# l y" _2 `& h, u5 J, }* z& s imp.transform(x) * G- N8 i1 {8 b3 N
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 " g; k9 M4 L/ O) R
import scipy.sparse as sp
2 U. }" o; B* N' a; Q # 创建一个稀疏矩阵4 Q! p' t; V3 c: I) ]% f5 V
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
7 v y; y8 v8 | imp = Imputer(missing_values=0, strategy=mean, verbose=0)- M; P0 H& M0 a0 }- u: T
imp.fit domain name is for sale. Inquire now.(x)
* k( X: _* X, F4 N8 `5 A x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])" f8 ]0 Y! b' U# x+ G F( W
imp.transform(x_test)
+ H E& J% s3 t$ Q 当我们拿到一批原始的数据
a; m% E1 S! o7 A5 F/ D, { 首先要明确有多少特征，哪些是连续的，哪些是类别的。 - p/ z: s4 }: P1 [7 n
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
T! J8 ]! k- l, h. h2 G; T9 B6 \, q 对连续的数值型特征进行标准化，使得均值为0，方差为1。
# ^# z* ~( v) D* ^% F7 i 对类别型的特征进行one-hot编码。
2 g! K/ z( `3 G F7 M 将需要转换成类别型数据的连续型数据进行二值化。 * k) `* M7 A _+ n z; e1 K
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 # V% m! A: O s! v- Q
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 & A7 B* ?! H+ P: ?1 i+ D: p
根据实际问题分析是否需要对特征进行相应的函数转换。 2 @/ g: Q! A* y5 e& X1 M6 G
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ; i$ M/ v' F* e- N; X( F
因此针对动态的数据可以采用如下几种计算方法:
6 z0 K) b3 j- x' r: s. i 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
* n1 @2 ~0 x" @1 B. k! i/ p2 f- f! R8 d
, B6 u+ ]; G3 c& H& d2 V( T5 F, k' w, H6 I
6 Y6 ^1 h$ t" R5 p2 h
|
