|
. F ^; a0 u o j sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 5 D; c& \4 E2 @6 f, M
归一化是标准化的一种方式, 9 `; {0 `/ Q: U+ [2 L
归一化是将数据映射到[0,1]这个区间中,
F) A0 h9 |5 \# B 标准化是将数据按照比例缩放,使之放到一个特定区间中, , }9 G0 W" A; k: K* }+ `* c
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. # Q; n$ U0 f; V% v2 a
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) 7 H! e4 R: l" W4 A& D. u
导入模块:
) Z5 o% k/ V- i( f3 |7 T from sklearn.preprocessing import StandardScaler- @8 z; K# \! X4 }
from sklearn.preprocessing import MinMaxScaler
# A* e9 i9 M3 [5 ~) l. S; W; F from matplotlib improt gridspec
9 w- U6 c6 n9 s& j4 m8 F import numpy as np6 x R4 b- _, a# h2 o, q* n* N M
import matpotlib.pyplot as plt ; _9 V# J% z; S; ]$ c! T5 f
使用sklearn 进行标准化和标准化还原
( t" H* m3 @, J& ` 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
* a+ P1 P' O! S- Q! X std = StandardScaler()
6 ^2 S+ j# f. A! @! `3 Q$ e4 l3 l data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])$ Z! f- \# {: v3 \' f. F
2 B4 i; P) h. D, [+ d/ t # 将标准化后的数据转换为原始数据。
3 t4 @/ g$ ~% U( N std.inverse_transform() , g; ^7 w- x7 \0 N
查看标准化后的数据的均值与方差 * c. l3 N8 H. y: L
x_scale.mean(axis=0)# 均值 5 u9 H2 o, \) s3 ^3 g! @2 r
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
# y$ Y1 a A' i0 u. Q x_scale.mean(axis=1)
) I6 B6 N& l+ \1 T* w ` ) r6 i% D+ u5 b
cps = np.random.random_integers(0, 100, (100, 2))
( j& J/ O! W1 s6 G # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
; P/ ^- }( }( X( Q0 N" p; w% p% Y ss = StandardScaler()' `( U) _0 E% z/ |. ~7 p; ~
std_cps = ss.fit_transform(cps)
" R/ ^) o# ^! Z' A gs = gridspec.GridSpec(5,5)
! f- _: G/ b0 T7 Y9 B6 d fig = plt.figure()
7 }+ o, {# Q8 a ax1 = fig.add_subplot(gs[0:2, 1:4])2 s2 N6 U- u! S) w {
ax2 = fig.add_subplot(gs[3:5, 1:4])2 b7 V7 F. S. |1 m! T
ax1.scatter(cps[:, 0], cps[:, 1])
9 E( \6 D4 F" }' x1 A1 A: q ax2.scatter(std_cps[:, 0], std_cps[:, 1])# [1 j0 \: w/ E, U
plt.show() 8 ]# X% T- _/ S
` : l+ D& q* G9 w7 g
from sklearn.preprocessing import StandardScaler
/ k! G% }; R3 Z+ @/ H from sklearn.preprocessing import MinMaxScaler( P5 c- t& H; x, q7 J
from matplotlib import gridspec
/ v' I3 Q1 P/ |1 J2 P, D- p; c; X import numpy as np+ d. l; ]3 \( e+ h
import matplotlib.pyplot as plt4 ?1 Z1 R, P+ Z% C9 p% O" j1 J
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
, L; r, Y5 E ?- E ss = StandardScaler()
2 {* @. W6 P3 ]% O6 I# ~ std_data = ss.fit_transform(data)7 A7 T* C/ r B3 Z+ M0 @+ `7 x
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据# E3 y2 n6 o* {/ ^4 j
print(data is 原始数据,data)
5 R- K% R2 k; ~( i5 @ print(after standard 标准化后的数据,std_data)6 _0 P6 M) g9 B1 i; b
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
4 h6 Q- g0 I) Q' I: D4 J+ S print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
; B! f: Z! c T4 Y& ? E) x* K 使用sklearn 进行数据的归一化和归一化还原.
$ N: `# O4 A. a* R9 T data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据; g9 b3 o0 R. ?9 e3 I
mm = MinMaxScaler()# 创建MinMaxScaler 对象
: j( F! i+ W% u8 ~- L! h mm_data = mm.fit_transform(data) # 归一化数据
. I3 s1 D( x3 `: Q, r1 N7 C origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
( B: k3 r3 p7 f8 s5 b print(data is ,data)
; d1 D7 O% q0 g) K5 p7 p! y7 c print(after Min Max ,mm_data)$ _; m' ]3 _) S1 d1 O( e! G
print(origin data is ,origin_data) 9 V: g4 D/ S; {# j/ O
MinMaxScaler和MaxAbsCaler:
# x7 O) A+ }3 b2 E: t% I MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
: Q, Y& ?( c$ E) z7 c G3 G MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
# g3 w, r: S9 S0 B# p* q min_max_scaler = preprocessing.MinMaxScaler()
" Z, H1 J$ x7 I2 J x_minmax = min_max_scaler.fit_transform(x). f# b5 B3 B" j
x_minmax - x4 V" `/ @. W0 L2 V
对于新进来的数据,采用如下方式进行函数调用:
/ V& y! Y0 a$ g: \. ^: s x_test = np.array([[-3., -1., 4.]])! y8 c2 ? ^/ V4 N
x_test_minmax = min_max_scaler.transform(x_test)/ W8 r# m1 u$ g3 |3 x6 Y
x_test_minmax
+ x8 x* P% R8 _: o' n2 p- r MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
7 f0 J3 X- M% A- A$ `2 u max_abs_scaler = preprocessing.MaxAbsScaler()+ x4 M" @/ ?/ v. H& q& N
x_train_maxsbs = max_abs_scaler.fit_transform(x)
3 g; C, W3 r! X x_train_maxsbs 9 n/ q& p9 P* V$ E& h
# 同理，也可以对新的数据集进行同样的转换 ! U, I& p5 U% x
x_test = np.array([[-3., -1., 4.]])8 J2 U; _2 T$ k e _3 g
x_test_maxabs = max_abs_scaler.transform(x_test)4 s& n) z& C+ }" K' X: N* a R) A- ]
x_test_maxabs
' S' o( ^- c3 `1 e! q8 ^* T% Y' o 针对规模化稀疏数据
$ d" e0 W$ `& q$ O 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: 3 R1 |6 p# i7 r5 `
MaxAbsScaler,和maxabs_scale + W B" W' E1 h6 G* n. S& k
针对规模化有异常的数据
. E% T4 a1 p5 w$ V" s! N7 \ 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
. ?( a) X* ?, c# S2 U/ c 正则化Normalization
0 @9 X4 E' [+ T _ 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
6 G& o- X3 U) _ L" U* h H @ x_normalized = preprocessing.normalize(x, norm=l2)' S* S: X. g$ P! s8 E: e1 f
print x
9 K( [$ ?/ {! M, B print x_normalized
& p L% h1 b t( x # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
* N7 L% n- Q+ w normalizer = preprocessing.Normalizer().fit(x)
5 s% W' A/ n1 j normalizer / o% I% P5 I- `4 N6 P0 m8 M* a
# 对训练数据进行正则 1 r; T/ q- d+ A5 R( E
normalizer.transform(x)
& i( P, B( X( q0 o # 对新的测试数据进行正则 7 S+ E9 f2 X* Y% Q+ n3 \
normalizer.transform([[-1., 1., 0.]]) 6 w! _6 w3 l0 |7 \, A
二值化( x E/ s% N7 [! ~6 e
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
. `( h0 w* {: B from sklearn import preprocessing
+ k+ \9 _; |# y3 i# [ import numpy as np
- O% e. c' r+ p: ^; i9 t5 c* c9 r
& G/ g2 z0 i) X, L* W # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
* N8 K% o: x m! `+ W x = np.array([[1., -1., 2.],
! Y. O M. r5 Q# u& C, o4 u* Y [2., 0., 0.],
0 h2 I* k( i A5 @- R [0., 1., -1.]])- R( R9 _9 R6 u- T1 O
8 F/ Y1 I8 d8 u& d0 p
binarizer = preprocessing.Binarizer().fit(x)
/ n6 z8 w! z- J; d binarizer.transform(x)3 v; f6 p6 ^; Z- k0 O
, s: B/ [ d& p: f7 Q
binarizer = preprocessing.Binarizer(threshold=1.5)
8 W5 H" l% W/ u( v# _ binarizer.transform(x) 1 O6 e! i/ q! Y( |1 Q
为类别特征编码
& J$ ]; A& H8 l# K. Z* }9 K8 w (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. 3 v3 b6 X8 ?* I& i$ Q
OneHotEncoder
5 t/ w- u2 P7 M, z 弥补缺失数据5 Y; K n0 C t( J
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
5 T8 U1 P! N: N* t3 @7 V import numpy as np! N0 ~$ u2 d" y1 {; f, w
from sklearn.preprocessing import Imputer
; `" r' e) q1 B6 }$ i( \ imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
: N2 m g7 j: Q$ F: A3 w imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])4 ~5 Y. T% W, ]- J4 [1 L, I( O' a
x = [[np.nan, 2], [6, np.nan], [7, 6]]
9 F. p2 a+ f4 X/ q imp.transform(x)
/ t4 Q, v6 w( p! ~; X Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
- b% z( P7 @4 y9 ~" d import scipy.sparse as sp
6 `# g6 u9 F0 o& M- E' B( d3 u% y # 创建一个稀疏矩阵4 j8 m% Y2 v( {1 {5 S4 T, H4 U
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]]), X9 z' ]; H" c8 H- y J
imp = Imputer(missing_values=0, strategy=mean, verbose=0)& E- |& I `8 L5 ]8 W
imp.fit domain name is for sale. Inquire now.(x)
" Z. u* K6 g. h, F, y x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])1 u3 i1 {# T* f& x; H& Q1 F F6 J- i
imp.transform(x_test)
; M# P2 L0 V) S5 P* } 当我们拿到一批原始的数据 4 a+ `' ]' m& A( L+ J4 n8 C* n
首先要明确有多少特征，哪些是连续的，哪些是类别的。 . v6 G" [6 B% d: ~
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 ; A3 [. v( B& K$ ]; J9 ~( }
对连续的数值型特征进行标准化，使得均值为0，方差为1。
- r7 U1 I* ^/ ]8 W- q 对类别型的特征进行one-hot编码。
/ l/ o% P+ S. ~$ [, ]1 z 将需要转换成类别型数据的连续型数据进行二值化。
5 S0 ~0 [$ t- x) ] 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 6 s, m: N7 p4 S6 C, ]
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 & e$ t E$ a0 F* U5 ~9 E
根据实际问题分析是否需要对特征进行相应的函数转换。
0 F* O9 T5 F5 m, \6 } 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
S+ J' x7 d8 h8 @' y 因此针对动态的数据可以采用如下几种计算方法: ; }) ~ Y+ y& u X# j
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 ( n A9 w# v2 W
( U3 ]& _/ b! q6 ?: i6 t2 P; @+ P
/ h1 @" s/ T- J: K4 G* O3 v0 ~0 ]# ]9 `. K; l- L1 v2 {, K# v
: C: q$ O9 r% \1 W& R$ q |
