|
2 p# t. k2 h! J sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
Y7 P$ k; i+ n y& Y: m 归一化是标准化的一种方式,
. l1 Q1 ^- S, o. I 归一化是将数据映射到[0,1]这个区间中,
" b& L- a1 q. ~+ S, ~1 F; |1 { 标准化是将数据按照比例缩放,使之放到一个特定区间中, ! J2 c0 y" B ]
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
n" p8 d; }& O6 S- b 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
( |) H/ n4 s0 s( u, v/ E4 L 导入模块:
$ y! ]+ Y* Y% |% O1 q. O from sklearn.preprocessing import StandardScaler
& Y- c0 @1 M. x from sklearn.preprocessing import MinMaxScaler; M& \1 ~' J7 h" C
from matplotlib improt gridspec
& z* v$ A$ `) C& H, ~0 ?% w import numpy as np
& d# m* _8 U- |0 l6 ~ import matpotlib.pyplot as plt
/ d1 C1 J# O! Q" K 使用sklearn 进行标准化和标准化还原
! T- ?+ m+ p( G* \& y$ e( x 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
. q1 Q/ A8 W! R( e# S7 r! X std = StandardScaler()
. x2 O; f! T, \% r. v7 g% d data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]): w, E: m; M6 u4 r) S: c
) I- w2 { `' S1 J9 S* j0 D6 u
# 将标准化后的数据转换为原始数据。- C% t5 g) n4 J
std.inverse_transform()
6 e9 E8 }& m& V( \ A 查看标准化后的数据的均值与方差 3 d1 v0 x" A6 U) l: X8 q
x_scale.mean(axis=0)# 均值 * r3 g* y) l. v
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
% h9 O4 b, z' D8 I, ] x_scale.mean(axis=1) ( U- p: @( w: Y" a3 N' |) ?* Q, r: J) {
`
# X: B+ k3 Z! Y, v( ~ cps = np.random.random_integers(0, 100, (100, 2))/ u; {% P7 w2 I
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
9 Q& F& w7 k0 p" S3 j) p ss = StandardScaler()
) A; @) [ R& t4 F3 j- d4 o7 U$ Y) G std_cps = ss.fit_transform(cps)
/ p/ B: ] F( |9 m gs = gridspec.GridSpec(5,5)
8 v" s& }+ {0 F fig = plt.figure()
9 c* ?# u9 \0 \ ax1 = fig.add_subplot(gs[0:2, 1:4])
* C$ [, n& O' i- x+ _: q2 U6 ` ax2 = fig.add_subplot(gs[3:5, 1:4])
; y" A4 K& ^ x6 F1 e ax1.scatter(cps[:, 0], cps[:, 1]). k' |0 G0 e9 D2 b* W' U; G- E* ]
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
/ C! U! ~2 l0 ]/ f a1 w; o' T plt.show()
+ \. u8 B- ` T1 m# B7 m/ }1 R: f `
; J- y2 ~& \- C7 z$ v8 N% z. J/ ~ from sklearn.preprocessing import StandardScaler6 ^) Q/ \; r4 ]7 w+ S
from sklearn.preprocessing import MinMaxScaler z. f. _; R5 S3 ]7 l( J% D4 P1 Q
from matplotlib import gridspec
! h3 ]0 e' n& @ import numpy as np+ T) i; |! a9 T# f
import matplotlib.pyplot as plt
* Y' H# \4 E! r2 m$ a5 D data = np.random.uniform(0, 100, 10)[:, np.newaxis]
( a v" i! k& u$ f2 o6 L ss = StandardScaler()0 O; T* Z# l. j7 q/ `
std_data = ss.fit_transform(data)1 W% o) t5 C+ b5 e5 x2 Q( O
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
. E4 B: J/ I9 X7 `: B print(data is 原始数据,data)4 A* `$ @! _; k/ l# ?
print(after standard 标准化后的数据,std_data)
" P6 Y( e4 ?; W2 N" @9 [! n% A print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
+ K" K" m/ k/ f( |6 K7 S print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
! A( C/ ]) z$ n6 c: l 使用sklearn 进行数据的归一化和归一化还原., @- g6 J. g! V7 d) f
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
* } w8 R) e" k* [ mm = MinMaxScaler()# 创建MinMaxScaler 对象. ~+ m6 V5 ^) Z) h
mm_data = mm.fit_transform(data) # 归一化数据
- R6 R& _; q/ \* K origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据1 l+ _+ i& }+ H6 j
print(data is ,data)
7 x. Y$ @# X! n7 i print(after Min Max ,mm_data)
! j; F: I- `, u8 o( x# u4 C print(origin data is ,origin_data) * s& N) s; t! W7 x& ?) l
MinMaxScaler和MaxAbsCaler:+ G; F* P D' ^; A( B1 f
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
- Y4 ~1 N0 v6 |& ?0 K( c4 r MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 ! K# B) ~6 t1 Q3 u f# t# @
min_max_scaler = preprocessing.MinMaxScaler(): q$ r" B" ?, W% ?1 m
x_minmax = min_max_scaler.fit_transform(x)3 J+ R" b- O3 E" O9 m7 I
x_minmax 2 p: ^0 n1 b6 f
对于新进来的数据,采用如下方式进行函数调用:
! [. M4 B+ A* ^' I! ^" y x_test = np.array([[-3., -1., 4.]])1 E% l- k3 M v. i3 G
x_test_minmax = min_max_scaler.transform(x_test), E/ v$ V; S' z; Q, A
x_test_minmax ; j; ~- ]9 {; I3 I) |$ n8 D. k
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
7 Y" y9 i4 t7 `1 c max_abs_scaler = preprocessing.MaxAbsScaler()
1 z6 N4 g* c" Y7 F1 G x_train_maxsbs = max_abs_scaler.fit_transform(x)3 i8 Z5 K+ x5 L6 B% I" P( m# A
x_train_maxsbs * }' }+ ]; o& O/ ^5 }, b x
# 同理，也可以对新的数据集进行同样的转换
3 v) e$ R" H# w7 k+ [ x_test = np.array([[-3., -1., 4.]])
6 A* r$ b. ~0 v' g. V, W! Z$ I1 Y x_test_maxabs = max_abs_scaler.transform(x_test)& E" J7 K9 m/ Z: t6 O0 \9 l$ }
x_test_maxabs
+ X! U3 Y [! ~ t. {) m- h 针对规模化稀疏数据# t# e" d: X. c: u) O. I
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: % a3 g p- s, F; f- o* l, X
MaxAbsScaler,和maxabs_scale
3 ~4 w7 X. ^/ c# m! u2 c 针对规模化有异常的数据
& Q, Y1 {+ U; \ 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. - k. Z$ | g+ D: m8 S- C0 P: T
正则化Normalization
+ d3 N @) {4 o. C, m3 B 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 ; d+ _2 @: }9 m* m6 V5 N. N
x_normalized = preprocessing.normalize(x, norm=l2)
% N& S( t; W6 s/ G print x5 f- S2 u+ V1 G0 e, N6 U
print x_normalized " u# \ q5 `: r4 X6 A/ o
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) 6 Z* m; z$ g: b6 ]6 Y7 w
normalizer = preprocessing.Normalizer().fit(x)
7 C7 _, U, k9 Q3 @! k9 b8 ` r4 r normalizer
4 g0 w$ M) z' G9 E+ i/ Y # 对训练数据进行正则
- }) ]$ }, @. \ p0 y( P normalizer.transform(x)
8 C$ Z2 s7 x9 `7 S; O% w# v3 }* P7 v # 对新的测试数据进行正则 ( ^0 e* p7 ~: s6 t3 e
normalizer.transform([[-1., 1., 0.]]) : P8 D- w/ r: M7 p4 C
二值化4 X/ n2 J5 n- ]3 g4 y
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 4 [* X4 X- G6 z/ |
from sklearn import preprocessing) b( X, H! P0 V% x
import numpy as np
" z. z- @* h& o* h5 }: ~7 r% u v5 v z3 D# m/ S
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征/ o) @# A1 v; `3 W4 D
x = np.array([[1., -1., 2.],5 h1 {, T: K! h5 w' Q: k ?
[2., 0., 0.],
9 e q4 |& g. f4 _* \ [0., 1., -1.]])2 X3 [( y0 B1 q% o
5 T/ F( I6 e1 V
binarizer = preprocessing.Binarizer().fit(x)
9 s- c0 p0 o6 z1 } binarizer.transform(x)
# v+ r$ f3 d- v( t# c
A8 l \) a, ]8 G: {3 P binarizer = preprocessing.Binarizer(threshold=1.5)3 ^# R5 G' k" n1 |9 `
binarizer.transform(x)
5 l7 M) ]0 Q; U6 g5 _2 @ 为类别特征编码: v- U. g( u1 P/ K9 ~4 I
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
5 n* x: e: `9 H( P, e( H OneHotEncoder
& A, _6 p, Z+ l" H 弥补缺失数据1 E: d1 }: U8 P
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. ) s' N! j2 @. j! ^! c
import numpy as np1 e, B, u9 g- H2 i/ {+ g
from sklearn.preprocessing import Imputer
) V8 I3 ?' b7 L imp = Imputer(missing_values=NaN, strategy=mean, axis=0)" w6 |0 ~, M; {! R
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])! y: ]. f5 [( q$ s3 W; l- |
x = [[np.nan, 2], [6, np.nan], [7, 6]]
' j( Q* j- `" N& @ imp.transform(x) ! g1 R* W# [5 S
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 ( i0 t; R# B5 ^2 A d+ v' h4 I
import scipy.sparse as sp. b: P( } ?& W5 e8 i0 P
# 创建一个稀疏矩阵
$ Y4 `, A L$ h$ i- @0 W x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])& H6 D. n. j+ [5 [$ O2 t8 `4 R
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
2 X* F5 ~6 h! J0 _' d2 p imp.fit domain name is for sale. Inquire now.(x)
$ ` U: L5 B8 P: B# b- t( e x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
$ u# ~6 ]4 e' R# k imp.transform(x_test) 5 Q. ^3 ]0 Y3 G) z; m
当我们拿到一批原始的数据 * e- v4 k% [* Y: ]
首先要明确有多少特征，哪些是连续的，哪些是类别的。
( S: i! U: e F' T 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
6 t# b$ W. @0 W$ T: B* \ 对连续的数值型特征进行标准化，使得均值为0，方差为1。 , P8 M. e0 E) D( K+ D' |
对类别型的特征进行one-hot编码。
8 n& f3 f$ V* J8 R% { 将需要转换成类别型数据的连续型数据进行二值化。 ! E$ _/ B2 l2 ?( x
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 : ~* T3 i" s. Y) G! e
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
8 J! m" e ~1 o6 a 根据实际问题分析是否需要对特征进行相应的函数转换。
7 G+ J6 \7 ^0 F* r% O 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ! C* T+ D7 d6 t1 }5 m1 N& w }: B
因此针对动态的数据可以采用如下几种计算方法:
% ^9 k; j0 P ^ I, z* C$ O7 C 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
1 S8 }$ v8 T* s
+ Y0 E0 d* ?. y, n- }1 Q" L. w' q% }
% z+ e- ^* N8 Y* u- r5 i% A$ o; T6 U$ p5 F2 B( p
" G% ~# V$ _& x" S/ T |
