6 a# `5 s% [1 |" G3 X( `
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: + p& o* P" S0 B# v5 v4 ?
归一化是标准化的一种方式,
% @6 i( s3 |! s$ t' o 归一化是将数据映射到[0,1]这个区间中, - A- F. h9 i7 v' a
标准化是将数据按照比例缩放,使之放到一个特定区间中,
4 j/ J% [$ ~* j1 J" F3 L 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
# x% j0 K) p1 x( k5 U3 x4 ~3 P 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) % w/ G0 R/ ~" B7 j
导入模块: 0 m( ?. N2 K( x
from sklearn.preprocessing import StandardScaler, f1 G8 O4 ]- V: Y" F' C; J* i
from sklearn.preprocessing import MinMaxScaler
% i, v% W- B( l+ a from matplotlib improt gridspec: H' }' @% }0 v* A9 y6 Y* F. @
import numpy as np5 T3 J7 M& G8 b$ Q
import matpotlib.pyplot as plt
, T8 B9 b) i+ t, e( H4 y; h 使用sklearn 进行标准化和标准化还原. k7 C8 {: K4 B1 X% T% _' N
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x)
: L g0 d- J; D3 J8 W; o+ g3 P std = StandardScaler()
L% D8 W/ B' S) X8 Q) k data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
1 x6 R7 H2 u) Q8 W. t1 Q( |0 L/ K0 ~1 k- L' E% I1 s% T- w
# 将标准化后的数据转换为原始数据。3 b }9 h$ i3 A/ E2 C& E \7 R i. i
std.inverse_transform() * H% o' y& C- j/ G
查看标准化后的数据的均值与方差 ' }1 M" t2 @8 D* |: M$ t/ c* l4 U* C
x_scale.mean(axis=0)# 均值 $ ^, `8 P8 W3 {. ^" f4 ^
# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作 - A8 J/ t& A" r1 E
x_scale.mean(axis=1)
1 Z7 ~, q `/ `& Z. [# w ` # ]" `+ \! |8 W7 j0 {
cps = np.random.random_integers(0, 100, (100, 2))
0 m$ x* p% h+ H+ F @( f" A0 B6 C # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
) W& Z* T. ^1 m" w+ K$ J% s5 Z ss = StandardScaler()) }) y+ I( e% |$ F" k
std_cps = ss.fit_transform(cps)
6 D' F4 o, ^- S$ `/ y gs = gridspec.GridSpec(5,5)( d7 ?2 j' j: x' Y7 q. [7 I* T. @
fig = plt.figure()
! [' _& Z/ i1 V ax1 = fig.add_subplot(gs[0:2, 1:4])4 u- `3 x; H8 E5 C: X) r! g
ax2 = fig.add_subplot(gs[3:5, 1:4])
: p( F+ Q; P- b9 T ax1.scatter(cps[:, 0], cps[:, 1])
9 ~! o g) E' B0 N ax2.scatter(std_cps[:, 0], std_cps[:, 1]): }; k$ U) B+ K4 |& [( Y$ l4 K8 y/ P
plt.show() + R: C! C; d& f: }+ Q" A% ^
` * P4 f% t8 r8 i
from sklearn.preprocessing import StandardScaler
& L/ `' N- K- S1 g, [( L from sklearn.preprocessing import MinMaxScaler4 ~: |" V( I3 \: e
from matplotlib import gridspec
; N! }$ K; g* F$ g( p import numpy as np* V) r x( G3 N4 \5 I# I1 u
import matplotlib.pyplot as plt" E* x" S. F( Q2 E I+ l
data = np.random.uniform(0, 100, 10)[:, np.newaxis]) @6 B' l. n( k) D0 q$ B) H
ss = StandardScaler()
3 ^9 _8 c8 j. ?* F std_data = ss.fit_transform(data)
1 Z* G3 r, _* E origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
. w; ^4 b* w( p+ m print(data is 原始数据,data)
. B2 D2 R4 Z# x$ J: } print(after standard 标准化后的数据,std_data)
) r. h1 t0 d5 H6 _7 v" R print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
- L! w# N D0 l& P w print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) / \; F) }! w* V, I0 t
使用sklearn 进行数据的归一化和归一化还原." K6 l; g. N" Z# w# x. I b; F, \
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据% v7 l* r7 M' r9 W1 E" a
mm = MinMaxScaler()# 创建MinMaxScaler 对象# p1 m9 r9 B7 @* C6 B$ B
mm_data = mm.fit_transform(data) # 归一化数据$ ~" P1 ?7 v2 L
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据( e* K( H' Z: c+ @
print(data is ,data)0 ?/ K. I6 J! ^8 M
print(after Min Max ,mm_data)
d1 w) F( s+ K( e4 |$ T print(origin data is ,origin_data)
: E X7 A. U4 \5 A7 U- K MinMaxScaler和MaxAbsCaler:, F* l" i9 {! v1 C4 H/ B% c. ^/ k% y, E
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) 1 v' m, b0 e3 {7 Y' {. P
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 + j7 i, N# v |1 Z' o1 `: y# P
min_max_scaler = preprocessing.MinMaxScaler()* ^, m) u* f2 U* P' T) k9 D+ K
x_minmax = min_max_scaler.fit_transform(x). ?) l: a0 o2 o5 ^3 l: M2 N; N2 ~' v
x_minmax
) v2 S3 p( y8 l0 a 对于新进来的数据,采用如下方式进行函数调用:
" _5 x8 N9 R9 T x_test = np.array([[-3., -1., 4.]])
( E" z5 F Z* j0 w: u x_test_minmax = min_max_scaler.transform(x_test)
" r# Y) d( u9 c x_test_minmax
3 X) D3 t8 j6 J6 q1 c MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
) B; B9 B; R3 P! t4 Z. q0 c max_abs_scaler = preprocessing.MaxAbsScaler()
7 ^6 L- s1 }, P2 ]6 Q' ]6 k5 v5 k, Q/ M x_train_maxsbs = max_abs_scaler.fit_transform(x)* R5 _9 l4 E6 T1 }
x_train_maxsbs
4 e4 B5 J7 b0 ~7 a4 [ # 同理,也可以对新的数据集进行同样的转换 0 R# e1 x% w$ ]+ \
x_test = np.array([[-3., -1., 4.]]) z" [; h: ], I3 \
x_test_maxabs = max_abs_scaler.transform(x_test)
' M1 _& p4 N1 X: ?% W, E# P$ l x_test_maxabs , ?; B6 K; e! {" j3 v
针对规模化稀疏数据% o0 K& w* k% ~! S; _
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
! w0 W: Q/ Y3 D1 ?8 e MaxAbsScaler,和maxabs_scale
0 x. {- P7 K% [9 F5 p7 w. Q/ K 针对规模化有异常的数据
8 X8 n2 a, X3 E( [- _ 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
# r2 ?" ~- k- X* u 正则化Normalization
D' s. w, U1 ~$ ?% C 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
$ s6 {4 {9 I% {8 A( W0 q) i+ d0 ? x_normalized = preprocessing.normalize(x, norm=l2)1 ^5 n4 Z0 M' q- _4 {0 \
print x& d, W$ `6 s! n! F
print x_normalized 4 N6 a0 T. Z7 b+ L
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
+ s4 @! v- b; u5 U$ c/ ?% r normalizer = preprocessing.Normalizer().fit(x): c1 Y# V- s* M! q r$ t+ r ^
normalizer / D+ D# d* W% q0 Q4 ~0 ?
# 对训练数据进行正则 ( @8 ~; F" O) B' q1 X+ q) _
normalizer.transform(x) / @5 E* m- X& E6 w
# 对新的测试数据进行正则 4 F4 n6 W; h& }
normalizer.transform([[-1., 1., 0.]]) ( r3 v5 ^' t9 Z( Z/ X: O+ ]: |
二值化
2 v5 C! a6 X" T; ^$ r! O' K$ B 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
0 \/ f& q) Y: z" c0 k from sklearn import preprocessing
$ B1 Q3 u1 e; Y+ e; h1 q5 I8 z& ]* F- V import numpy as np
6 i. o0 q: B3 a
/ M) d% k5 C: ?3 h0 ]( a k! D # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征, R" ?( r, X% [
x = np.array([[1., -1., 2.],
4 J" R+ E1 [' C* \: n3 p4 Q [2., 0., 0.],
( V, H- O8 v4 V1 f7 d8 v [0., 1., -1.]])
: @5 q5 Q# L1 g3 ]& x
; G4 i' u. v/ m2 s' T binarizer = preprocessing.Binarizer().fit(x)
' u" f9 U$ N* b. `, P" @( u+ C1 S binarizer.transform(x)% _4 o2 U6 _+ o1 t, `7 A2 C
# V# S, J8 T& w+ i
binarizer = preprocessing.Binarizer(threshold=1.5)3 l$ K# ~1 h% e) {) P0 b& j
binarizer.transform(x) 9 x$ U- f$ g4 z) n0 y D
为类别特征编码
9 w7 s$ l7 W7 A% Y5 A (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. 4 @# a f. v# c- G; i* C+ P
OneHotEncoder ' L9 B/ _% c- G& A
弥补缺失数据$ e7 _- M5 G8 q- C, w* B4 Z4 {/ z
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
, f, ^5 ]9 \. y import numpy as np: }" V o$ h" s
from sklearn.preprocessing import Imputer- E3 L6 p. f. }$ A
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
5 Y! {; n# F* H( _3 I1 B0 o imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])% h" g6 V: u! m' z& h; [
x = [[np.nan, 2], [6, np.nan], [7, 6]]
6 V# [0 _) w3 D0 S imp.transform(x)
- |$ X7 v) v# t3 P$ L( k/ G; e1 { Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值 ; R/ `' `( b, @
import scipy.sparse as sp
3 \2 q. y7 D$ V! W% | # 创建一个稀疏矩阵
- l+ q# J, P8 { x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
! j6 S4 }/ U; k, S& K7 V1 ? imp = Imputer(missing_values=0, strategy=mean, verbose=0)
$ Z. {* S6 A5 v* ]3 F2 D( R, n imp.fit domain name is for sale. Inquire now.(x)% h0 a! n2 k# Y3 a( i9 C
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]): A6 U. T$ W+ g+ B) [5 T
imp.transform(x_test) 9 G( Q/ h% m- T& g" U
当我们拿到一批原始的数据
: }4 h* f& W& b2 C! H. { 首先要明确有多少特征,哪些是连续的,哪些是类别的。 ( [6 ~# E4 @' U: m. d
检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。 6 K2 N! g* I2 \+ E
对连续的数值型特征进行标准化,使得均值为0,方差为1。
1 P& u1 Z& s6 ?& H5 Q8 t$ C) W: W! i 对类别型的特征进行one-hot编码。
2 z1 r+ M. R- [6 O% p 将需要转换成类别型数据的连续型数据进行二值化。
7 P* B4 X/ U: Y2 E: [ 为防止过拟合或者其他原因,选择是否要将数据进行正则化。 ( v; X6 H7 S! v; P2 G( E, P
在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。 ) F5 T+ d" h: j4 \3 h7 G( K
根据实际问题分析是否需要对特征进行相应的函数转换。
) T8 ~7 r5 @! R1 Z3 c 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
; J! u3 S) e* G' D2 N! c 因此针对动态的数据可以采用如下几种计算方法:
4 H, ~& `5 m4 W. _ 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客 ' f" h; l* Y, s& U) Z
; U3 S3 x6 v6 b1 H% a
2 E1 F0 ]/ y5 T) E0 l' w- N1 i. L
) C3 B* p1 N/ t' k2 u6 r8 H
9 p: Y9 E; J0 t y |