4 _3 Y. [, W7 t4 N sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: - {- O, b- H* G( g
归一化是标准化的一种方式, + V- `" [& r) e1 T1 T
归一化是将数据映射到[0,1]这个区间中, - Y7 o9 K" t8 p: M: z8 ~7 x
标准化是将数据按照比例缩放,使之放到一个特定区间中, 2 b7 C4 C# g7 n$ c6 l
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
% e7 M0 a8 F9 s) V 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
/ ]1 u O; W& y+ }$ T) D 导入模块: , d! E. _' ?- z# A
from sklearn.preprocessing import StandardScaler. P) L0 ]0 M' @
from sklearn.preprocessing import MinMaxScaler1 L6 c( H' S% S4 q
from matplotlib improt gridspec
0 o6 h1 r7 v. W- W" ^ import numpy as np
6 H* w7 j( W; B" Q' c import matpotlib.pyplot as plt - P* h) v; |" S- V
使用sklearn 进行标准化和标准化还原2 ` \( s0 Q0 |8 A
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x)
$ x+ U: ~5 @. }/ u3 L% F9 m std = StandardScaler()
/ X& h8 A6 O' y& K data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
/ ~, v1 t/ ^8 M# i- l7 _' t
4 @8 S/ u3 D; |1 n( O # 将标准化后的数据转换为原始数据。7 \/ s3 G8 ?* m9 f7 z: B+ f
std.inverse_transform()
1 d5 q5 H5 @1 g2 o6 D 查看标准化后的数据的均值与方差
% ?9 X! X9 b. t. s" ?5 F x_scale.mean(axis=0)# 均值 6 j* X( i* Y$ M& S$ w
# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作 ! n$ o+ A8 [. G* |3 I: ^; u
x_scale.mean(axis=1) 2 K: ?+ D2 I5 s% b# m: \. {
`
( ?7 o" g: t4 q, f cps = np.random.random_integers(0, 100, (100, 2))+ w7 e3 B! v' {' X: |' |
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
+ A$ _; K% t P8 A. L ss = StandardScaler()
, B% K: H. W5 u4 R$ Z- @$ J std_cps = ss.fit_transform(cps)
. h9 ~0 }% {' o; m gs = gridspec.GridSpec(5,5)
" f, n# ]1 X2 o9 b fig = plt.figure()1 l( v3 t4 F. n# S( \
ax1 = fig.add_subplot(gs[0:2, 1:4])
2 Q3 a% c7 n" `0 o) |5 W ax2 = fig.add_subplot(gs[3:5, 1:4])
6 n$ f, t/ O; J, N' s7 N ax1.scatter(cps[:, 0], cps[:, 1])5 B- I$ u3 g$ E4 ~# q; h
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
0 X6 I! ^9 X1 _8 c: @ plt.show()
1 p; k% g. E \2 M `
1 j# E5 S4 P! Q0 f from sklearn.preprocessing import StandardScaler D5 c+ w1 g0 y; k* v
from sklearn.preprocessing import MinMaxScaler
' N$ q: t9 ~: l from matplotlib import gridspec
! F1 n8 a! N% A* N1 ^$ `6 a# n: z import numpy as np
; }3 z% A7 V# G' j+ n import matplotlib.pyplot as plt
% E3 A9 E5 d0 D( B8 w# F8 Y data = np.random.uniform(0, 100, 10)[:, np.newaxis]
3 l2 J+ Q) J% A8 } ss = StandardScaler()
# \& r' L2 k3 ?9 W std_data = ss.fit_transform(data)3 M% B% h9 t, ]: ~8 _/ @) C
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
- W+ A6 S4 Q% e print(data is 原始数据,data)
8 Z I& D& [, ] print(after standard 标准化后的数据,std_data)8 c% Y$ m z* @3 |& O
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)* v4 W9 S0 y$ @7 @0 e U
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) 0 ]3 p3 w( X$ [; }
使用sklearn 进行数据的归一化和归一化还原.9 D. S0 o, A( F+ ~$ o( |% r$ Y
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据2 \8 Q- P u9 @9 t6 Y
mm = MinMaxScaler()# 创建MinMaxScaler 对象! d5 s4 t; w8 a a5 M4 |# j
mm_data = mm.fit_transform(data) # 归一化数据
: A% ] [& p2 p/ P3 {1 z origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据9 I3 t9 B9 H# W+ _5 @
print(data is ,data) g( o j5 O# F- Y; k3 c
print(after Min Max ,mm_data)
5 r" O# Z x4 z5 B print(origin data is ,origin_data) " Y, p! U" w- R- `, Y8 z- B
MinMaxScaler和MaxAbsCaler:/ v- G; E1 R1 v$ O8 k
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
9 } h- f, @% t% R4 T( n MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
* t* P5 F/ e1 k min_max_scaler = preprocessing.MinMaxScaler()
4 j% W+ u9 _# B5 A x_minmax = min_max_scaler.fit_transform(x)
3 \) k! L3 J" o: F, a0 r. d. m x_minmax
. h9 {0 D- `1 ~. j+ Y3 B% t 对于新进来的数据,采用如下方式进行函数调用: # i9 p! l, v, }3 g* t! M8 Z; Z6 L
x_test = np.array([[-3., -1., 4.]])' s: w3 _! [# G2 d0 ^( s: g7 S
x_test_minmax = min_max_scaler.transform(x_test)
; L; H4 T4 w7 J4 V& g8 u x_test_minmax
+ l; X( k: m+ w. O# x: M* l: [ MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. ) x$ N( q0 C! J9 ]: v. h3 X, U
max_abs_scaler = preprocessing.MaxAbsScaler()
& Z0 I3 e P1 H7 O9 }- W x_train_maxsbs = max_abs_scaler.fit_transform(x)
) N [. d, j7 S5 n' S x_train_maxsbs
6 j( e2 i4 B# [+ V7 v # 同理,也可以对新的数据集进行同样的转换
; Y# J/ |3 w4 n/ W$ Z1 s; H x_test = np.array([[-3., -1., 4.]])
# s: S8 s; f7 V4 F# v# r) h x_test_maxabs = max_abs_scaler.transform(x_test)" G; n8 u2 f* g
x_test_maxabs : i, [' h( W7 |1 b( O; d) A
针对规模化稀疏数据
0 v- j. b$ { {, }) w6 N 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
- F/ ] J, l; T% k MaxAbsScaler,和maxabs_scale ' U5 r: Y5 Y7 k5 s6 l! Q; f/ x
针对规模化有异常的数据2 k j% ^7 `, T `+ U. J
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. 9 ?* {# t3 M8 }/ w7 e9 C1 l
正则化Normalization
# W0 _( w8 z2 K7 l; j" R$ u 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
( J \. J! J& P% f& K& z x_normalized = preprocessing.normalize(x, norm=l2)
5 s" K9 r" C! d) m# y& c print x. O' n) T/ @! Q: `3 I4 t2 N) { {2 X! c
print x_normalized
8 K3 H% J6 Q' ^- J0 p # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
8 N( T l( J4 {) l$ _" V/ Y normalizer = preprocessing.Normalizer().fit(x)
" }* D8 o( e( q, S0 t: }2 i# p7 u normalizer + H3 g+ S3 u# g& K o
# 对训练数据进行正则
( S3 g* o1 E) M& E2 m! e% b normalizer.transform(x) $ g( I4 A: A% K4 E. L( g$ k
# 对新的测试数据进行正则 : L1 E- g, ]# v( e
normalizer.transform([[-1., 1., 0.]])
; V, N, i; V6 Z 二值化( P! C' A! @( r' `. n$ [, Z
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 1 R- x0 I r3 Q( h) J2 ^" z
from sklearn import preprocessing3 F9 y m8 r) o
import numpy as np
# o# {5 I1 d+ X6 W- o2 C+ C. Z" t3 J( `3 Q& B
# 创建一组特征数据,每一行表示一个样本,每一列表示一个特征
6 t5 u1 N1 e, Y# J x = np.array([[1., -1., 2.],; |) y7 X z( C' {* _$ P
[2., 0., 0.],
2 r& k! z" }9 r9 r: h [0., 1., -1.]])- p8 r9 X% |' L1 c1 _6 Q
& ]9 n3 @. X* {* T! I, N
binarizer = preprocessing.Binarizer().fit(x)
6 ]# ?+ T* P2 v7 `# D binarizer.transform(x)
3 w7 V4 Q& x. m) w
$ ~6 C) `( @$ [6 W& t5 H% v, s binarizer = preprocessing.Binarizer(threshold=1.5)/ B; H; {1 M* X+ ^
binarizer.transform(x)
8 l! n6 O% z6 m% C 为类别特征编码
) L7 i3 g) U5 O$ c! d (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
- L3 w( i2 }, t% m OneHotEncoder : w* ~: S9 s; b9 D" v
弥补缺失数据
$ v! l, j8 I" b2 P, A4 q 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
' c: s4 P. N4 n z* p2 f. |3 ^0 h$ ? import numpy as np" c s8 a& ?: i# f3 S
from sklearn.preprocessing import Imputer! l( R/ o% S" J0 o7 J
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)( \ e, {% V* Z% e! z# J) ^
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]]), ?1 l% p; H+ ?% v4 V0 Z
x = [[np.nan, 2], [6, np.nan], [7, 6]]& u% K( w: x! b' v
imp.transform(x) ! a; h8 p0 }7 m" O+ V1 s! X' O
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值 8 I' z6 ] q, u# T
import scipy.sparse as sp
2 @+ Z9 u; B7 c: }- K # 创建一个稀疏矩阵6 Z# n1 q- q$ l
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])$ c& e5 u, N3 N$ y- {
imp = Imputer(missing_values=0, strategy=mean, verbose=0)1 G, K% M: ?" y/ Q5 Q# a" g: y8 P
imp.fit domain name is for sale. Inquire now.(x)% O3 I+ e h: b
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])( z" j7 K! l/ D; \
imp.transform(x_test)
! X7 y0 }. q8 l: @ 当我们拿到一批原始的数据
- J$ N4 ^' j, s/ F$ b8 w 首先要明确有多少特征,哪些是连续的,哪些是类别的。
; [" P% S% K' Y8 k/ ?, h z 检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。 + \' @7 j4 O- }$ o) g! \8 d0 }
对连续的数值型特征进行标准化,使得均值为0,方差为1。
; |6 y9 ~ q! ?9 i. h$ {5 z; k/ x 对类别型的特征进行one-hot编码。 5 w! L" x5 X1 W7 ]1 }7 t3 S
将需要转换成类别型数据的连续型数据进行二值化。
3 Y) t2 |# q6 l2 T5 P. T% D6 p 为防止过拟合或者其他原因,选择是否要将数据进行正则化。
# T# R8 U. _, P 在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。
3 K) C' F- g$ x1 k8 X( F4 r 根据实际问题分析是否需要对特征进行相应的函数转换。 0 P9 n& x$ V- P
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ' J( |4 S0 _% m3 c, g
因此针对动态的数据可以采用如下几种计算方法: ! ?- z0 S2 |- M/ t* m
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客 w/ ~+ [" j; P/ [9 s0 c( I" c
" z% \9 M+ \, z* X# [+ {. S2 b" r, N# g8 t1 I+ l
1 b. N6 [1 C1 Y0 @2 J# V3 i6 P6 G8 C+ P% Z$ A4 j5 H' x3 c. y
|