|
1 @9 l8 X. g% P1 d' P sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
+ f7 U# Z* b' D! E) R. y& V- Q7 s7 \ 归一化是标准化的一种方式, # `. P4 _+ u1 O# w p4 r
归一化是将数据映射到[0,1]这个区间中, * g4 J* m7 ]1 [3 v0 R
标准化是将数据按照比例缩放,使之放到一个特定区间中,
6 J1 v' @7 y, D2 P2 @ 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
( g l; h6 C: U' X 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
# X! a: Z0 `# O2 y+ \3 k1 i# F 导入模块: + `- p) o" w+ Y$ ?, @
from sklearn.preprocessing import StandardScaler
* d! Q) J d. f7 r1 Z/ k from sklearn.preprocessing import MinMaxScaler
/ s& Y: v- Y9 e0 k8 O% Z& d from matplotlib improt gridspec- X! o) Y% h) A+ L! |
import numpy as np) L$ u0 O9 d" U+ [ s% U
import matpotlib.pyplot as plt # {, `& d) J1 a8 c9 b+ v" V
使用sklearn 进行标准化和标准化还原( U/ ^3 T' O, z2 d2 {0 L' B
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x) 0 h; K. L# _9 H4 f* W) y
std = StandardScaler()' D8 |5 I) [' l6 I5 V' F# j9 j7 i
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]), f7 f, U: k4 a) L& c! k$ u) I
( B4 I$ G- w- w. F
# 将标准化后的数据转换为原始数据。
* D7 O9 S4 S: A0 K std.inverse_transform() # v& n) P2 v% O7 o5 g0 s
查看标准化后的数据的均值与方差
+ ]7 v a5 ^# }0 s# ?) I x_scale.mean(axis=0)# 均值 2 p5 y0 R9 a* C% B
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
: n# v1 e) p. S4 p3 u! A x_scale.mean(axis=1)
[4 e1 s' W# P! a ` ) E" M$ p1 k: d+ D. r) O
cps = np.random.random_integers(0, 100, (100, 2))7 t* a. l: n7 e) j8 s1 D1 `0 q
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集., E! V8 v! \4 J; ^ g, ?0 r& f
ss = StandardScaler()& i8 `8 I q8 g( Z( D% |. Z
std_cps = ss.fit_transform(cps); J/ _ G& H. }, P, Y F8 d
gs = gridspec.GridSpec(5,5); K/ J& E$ D' J& E# }" U
fig = plt.figure()# W6 f$ E; f8 m, ~0 W" m% X2 T
ax1 = fig.add_subplot(gs[0:2, 1:4])1 r, }0 z) ?4 y% S! u% U: ~0 B
ax2 = fig.add_subplot(gs[3:5, 1:4])
! I7 y7 u3 B4 q M ax1.scatter(cps[:, 0], cps[:, 1])9 X7 z/ F- R7 z. A5 Y" H8 u- |) e
ax2.scatter(std_cps[:, 0], std_cps[:, 1])4 Y5 T: |8 M( j1 L0 U: a
plt.show() ) U* e/ N/ h, o/ u& t( d) A2 h+ u
`
1 m& [* n9 Y" e5 T* } from sklearn.preprocessing import StandardScaler
) `1 c9 Q$ k1 z# q. T1 }- R; k+ J from sklearn.preprocessing import MinMaxScaler
9 h0 p$ g! w! W! O* C- T) d' |' r from matplotlib import gridspec. ~1 l9 }+ }; v5 M; `* X
import numpy as np- i+ ^2 _0 ?2 C: z4 n: P5 o. K5 z
import matplotlib.pyplot as plt" x, ^! r- O' u9 g7 s# P
data = np.random.uniform(0, 100, 10)[:, np.newaxis]. x% P( U# T- u% j: X
ss = StandardScaler()
7 X6 q8 i. K5 ? [" O3 ` std_data = ss.fit_transform(data)
& f$ Y( \8 F i, Z! a" ?1 M7 K" H origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据( f" k% S% x: `
print(data is 原始数据,data)2 \0 c) h- N8 E
print(after standard 标准化后的数据,std_data)
$ b) D3 r, |9 s( K# R print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data); H0 C ]4 p; o N
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) 8 q# o7 Q; D$ n- p$ Q' F& i0 d
使用sklearn 进行数据的归一化和归一化还原.
4 K: _( w; Y D+ `2 _ data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
3 ]' x7 a/ V) e! L) ~; p mm = MinMaxScaler()# 创建MinMaxScaler 对象
8 ]; Z/ Q/ s2 Y: _4 T, E mm_data = mm.fit_transform(data) # 归一化数据
* t- T/ \7 n9 t, E origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据+ h6 Z- i1 b) G
print(data is ,data)
+ D* D# \) r1 |' [( ~. Y print(after Min Max ,mm_data)* J- l, W; n! l, ]0 L
print(origin data is ,origin_data)
8 V' Y0 w9 k" {: h- F MinMaxScaler和MaxAbsCaler:
# I6 G) ?5 D/ J+ J+ p- O( q MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
! C- X8 c) |8 n MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
& g6 m+ M# i! N: B7 I% [ min_max_scaler = preprocessing.MinMaxScaler()( i/ q" t) Q9 F s
x_minmax = min_max_scaler.fit_transform(x)& s+ l1 z* M D: _0 @' O, }+ F
x_minmax 2 B8 o3 B4 P+ h ?
对于新进来的数据,采用如下方式进行函数调用:
4 m. Z/ {' J% g- W* ?8 M" S' p x_test = np.array([[-3., -1., 4.]])% w* ]" m, X( l+ b& V
x_test_minmax = min_max_scaler.transform(x_test)0 P3 [1 y: @2 V3 | r
x_test_minmax ( U: L- O" O; z) r+ e( Y
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
+ x% I7 `& C, C5 P5 ~* Q6 x max_abs_scaler = preprocessing.MaxAbsScaler()
* H t G/ w, P x_train_maxsbs = max_abs_scaler.fit_transform(x)5 K( f+ a, D3 F5 H1 s
x_train_maxsbs % p) h/ E* z' M q& J
# 同理，也可以对新的数据集进行同样的转换 % x+ T; B3 o- v# i. u
x_test = np.array([[-3., -1., 4.]])
" A$ |1 A' p# A x_test_maxabs = max_abs_scaler.transform(x_test)8 |+ p9 T) J% n* r
x_test_maxabs 6 r; ~& O+ m0 k- V2 Y; G+ P& j. O6 ?8 v
针对规模化稀疏数据
' v; w. n( z" d* h. b5 P 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
+ t' n1 A) k: H4 w$ ~2 s MaxAbsScaler,和maxabs_scale , H3 e. ]$ y' v7 o
针对规模化有异常的数据
" ?$ D" V9 R9 H, q' v" r$ A* Z 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. ) b9 o! b& w! ]
正则化Normalization: f1 J! ?* D$ w
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
; y9 M5 C' l7 c" _8 l" _ x_normalized = preprocessing.normalize(x, norm=l2)
2 P6 S" p% x& E$ b print x# m: U& j0 l" W+ D4 C
print x_normalized |+ y; C* [( t& D# L
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
* u$ p M* M& G+ T% Y' M! M* d( _ normalizer = preprocessing.Normalizer().fit(x); J, r& d: e6 [5 C. ]" D6 y2 U
normalizer % o }% `0 u/ @& r( r. ^1 ]) R
# 对训练数据进行正则 ' O7 ^% L. R3 x9 r7 v) P( [
normalizer.transform(x) ) Q( _& f+ l9 @- K( l
# 对新的测试数据进行正则 3 M B5 N! v3 K( H4 `3 J5 _( @! y; o
normalizer.transform([[-1., 1., 0.]]) 0 \3 q: N% q2 S
二值化9 b; m2 d- c2 Z. L
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
7 R: B- y U& R( b5 Q from sklearn import preprocessing/ b+ H: e. M2 [% T
import numpy as np
" m! C. B* E9 I
# q: }5 g! h" q/ Y) D # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
* k! Z( A: `) \3 V x = np.array([[1., -1., 2.],2 c! {+ Q1 G5 C2 v! [2 A8 }
[2., 0., 0.],
( l5 p3 c1 W, ^+ }/ P, J [0., 1., -1.]])
; F( } Z. a& ]' ^$ y, Q/ H- d8 q0 u) M3 S5 B3 f: Y2 ~
binarizer = preprocessing.Binarizer().fit(x)/ c, l. R+ |' A8 `5 V1 e
binarizer.transform(x); Q6 r! h, L m8 d v [$ I
( R. v, A/ [9 n binarizer = preprocessing.Binarizer(threshold=1.5)( R* |& v; E4 b" M0 f3 N1 v
binarizer.transform(x)
1 K/ _8 g% Y) H! }: i 为类别特征编码 t f1 w, ~( ? ~: Z" j: c1 u
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. " z9 X3 B( S- p4 x! Y# i8 Z9 ^
OneHotEncoder ; X' P6 b. R2 ] U
弥补缺失数据
: u4 K. W" X7 D" i% q 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
2 x+ u0 W2 }& S% g2 B import numpy as np# q' H" S) G6 a4 s( q
from sklearn.preprocessing import Imputer
/ Q* Y! _3 D& r4 q( S imp = Imputer(missing_values=NaN, strategy=mean, axis=0)5 Y6 Q: K3 v/ J K" J
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]]), d5 V0 S3 X2 ` T- }) f
x = [[np.nan, 2], [6, np.nan], [7, 6]]
8 a( `/ ]% }+ p2 i4 f( q! l imp.transform(x)
3 t, O" C# b8 K4 I Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 3 |' L! f, o3 ?& @0 _
import scipy.sparse as sp
. N. J2 f+ h; K # 创建一个稀疏矩阵
. B* Z1 b( i/ U3 o+ m x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
3 A \' R0 ?; f+ ? imp = Imputer(missing_values=0, strategy=mean, verbose=0). H- `6 p+ v& a
imp.fit domain name is for sale. Inquire now.(x); }- E2 h2 j4 O7 M1 ], O
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]) w% q, w* f, t7 y6 h5 J6 o, T
imp.transform(x_test)
! C- R: N2 ^2 } 当我们拿到一批原始的数据 5 b( x, g% r% P c) Z1 Y
首先要明确有多少特征，哪些是连续的，哪些是类别的。
& {0 q/ _; o5 ?" z6 l 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 / e2 V3 C/ G0 a( }
对连续的数值型特征进行标准化，使得均值为0，方差为1。
) s# Y, e( F4 [- z+ M$ A) N 对类别型的特征进行one-hot编码。
' [& L. U3 A0 N4 f8 C6 q" O 将需要转换成类别型数据的连续型数据进行二值化。
) u8 p' T; w; y. q 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 0 T0 l3 a4 A- _3 c0 B
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
4 L4 w, j# K5 u* S( r h 根据实际问题分析是否需要对特征进行相应的函数转换。
# i% n0 g/ s) r$ m: t& @) Z7 ] 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
- i' X: J# V- D( A$ U( P) C; B 因此针对动态的数据可以采用如下几种计算方法:
- C; S/ K& t! u; C% Z 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 % f! R! B+ _$ K# L6 A7 j \1 }
Z+ A, w$ n6 X X
) V6 ~/ u" r/ J u
) u9 k* V& y% `; s8 T) M$ p8 x0 ~
! p, W/ }7 s: x; b5 C% c: B9 t7 k) U |
