|
t) Q* O+ g: ?* Z% I O sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 2 V) S' {# W0 p' G/ q5 G
归一化是标准化的一种方式,
4 n* c4 \0 P) j# M6 V2 Y6 a 归一化是将数据映射到[0,1]这个区间中,
! z' L$ ]1 J7 ?. | 标准化是将数据按照比例缩放,使之放到一个特定区间中, ) w- E, z1 A+ {8 c W2 [' a6 e
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. / ]* @' ~. \, D+ r( d
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
. X7 K0 Q7 p1 M" R 导入模块: 3 j: U) E) c+ b& v( K# ]1 J- _
from sklearn.preprocessing import StandardScaler
6 Q* b. v R5 r from sklearn.preprocessing import MinMaxScaler( E1 v9 ^* T0 ]8 r
from matplotlib improt gridspec9 r* P2 J" k( ^5 e: @% T& O+ Y& ]
import numpy as np& ~8 ~2 u8 n& J, A& m
import matpotlib.pyplot as plt
3 p+ `' M( g6 a- Z A; I! z. T. H 使用sklearn 进行标准化和标准化还原, I8 Y" S& @" g
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x) ' m4 P4 p8 p4 v' w" x
std = StandardScaler()
0 H! A6 o/ f1 }* x E H- F data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
) Q, k$ m$ G& b D X. a' S# n
# R, a$ Q0 b$ F # 将标准化后的数据转换为原始数据。
! U! A! R, U7 X- i, f std.inverse_transform() ! S) Q$ H7 j1 {* j7 L; p
查看标准化后的数据的均值与方差
7 k% T3 J1 |9 J% I# i8 d x_scale.mean(axis=0)# 均值
# |8 w4 R+ Y! v: p' o- a. q1 p& E, f # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 2 I! k, P; y) d( b
x_scale.mean(axis=1)
7 s% d+ j8 c5 U& c& i& `. _# M- ]0 ]8 G/ k ` # h5 d. X3 _0 z
cps = np.random.random_integers(0, 100, (100, 2))
( ^9 K: p3 u' q+ e7 l9 Q- U # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
0 K# K9 m, M" G- Q3 E ss = StandardScaler()# l6 [# u+ L0 j1 z, O
std_cps = ss.fit_transform(cps)' y/ D# E( I) [- A
gs = gridspec.GridSpec(5,5)
4 H& g" Q, G, e fig = plt.figure()( ~# C; @1 r7 f: ^. @' T* H" e5 K
ax1 = fig.add_subplot(gs[0:2, 1:4])
' d3 ^' z3 T" F9 b$ U% e/ u; U ax2 = fig.add_subplot(gs[3:5, 1:4])
+ b, c$ ]/ T" n' V. q) t ax1.scatter(cps[:, 0], cps[:, 1]), r( ~: ^7 u2 B
ax2.scatter(std_cps[:, 0], std_cps[:, 1])8 \; a/ m* C1 x8 R- P& j6 S% B0 t- X
plt.show() # o# |" H3 H& ]0 y& O! Q
` " D+ {! }. Z0 _' j* Y5 f
from sklearn.preprocessing import StandardScaler
; S5 k' L4 j2 B+ G* f3 n from sklearn.preprocessing import MinMaxScaler/ i# R9 X& s' H2 q' j$ \- O" M% G G; x
from matplotlib import gridspec
$ B! C9 E( v! J6 y h import numpy as np$ B9 M3 o7 B0 ^0 f5 E
import matplotlib.pyplot as plt [! r) x8 t _% K0 [, M
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
, ] j, ]9 `; W7 }' @0 { ss = StandardScaler()0 W4 h- M& b. ~2 e2 W5 X
std_data = ss.fit_transform(data)0 q' z8 S4 E3 Y7 t5 x" d+ P. D7 g1 X
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
# Z, }+ l* o8 ^. Z' ^ print(data is 原始数据,data)* R& [" R- \. G; ?
print(after standard 标准化后的数据,std_data)+ V0 v i% h; g A; [3 y
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)+ @8 A! V5 a' t8 Q+ b) x& @
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
3 z- }3 J6 u" ]- ~# { 使用sklearn 进行数据的归一化和归一化还原.9 `( Y2 z4 `, k c$ c
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据 H/ ]1 L& g5 u* l
mm = MinMaxScaler()# 创建MinMaxScaler 对象
# H& m5 w/ A* ~+ L! b8 `8 [ mm_data = mm.fit_transform(data) # 归一化数据
1 G5 @# ^# C. I- B, k+ q( f. I origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据4 T4 @) n& Y: u6 n) ]6 O/ E
print(data is ,data)
/ V! g. v5 o8 d( O1 m- B& R* N* \ print(after Min Max ,mm_data)
4 ^) d5 ?: f# {4 q3 p7 @ print(origin data is ,origin_data) % ]! }+ r+ e& i
MinMaxScaler和MaxAbsCaler:
+ a% F" ~5 ]1 k( e% {) o MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) * E/ L9 ]: p4 [( g
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
* Q6 s! ~) g- t9 c' D0 F$ C& N min_max_scaler = preprocessing.MinMaxScaler(), r/ B" O) h1 I. k* v, z6 A9 Q6 W
x_minmax = min_max_scaler.fit_transform(x)
3 l. q" _. N; a, Y$ l [: o x_minmax 1 H/ H" E3 L! l2 O
对于新进来的数据,采用如下方式进行函数调用:
, b2 h$ C9 C( ^% _+ C6 G7 `: Q) d x_test = np.array([[-3., -1., 4.]])# @# b) d. N: \0 }; R
x_test_minmax = min_max_scaler.transform(x_test)! ?' V) H% H8 h+ {6 L: D# a
x_test_minmax
$ z' P, \% d9 B+ c( e; f T- _ MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
3 M% r2 A+ X6 Z) p' L, H: R max_abs_scaler = preprocessing.MaxAbsScaler()
6 o1 Q1 g" W% r. b# S1 l2 q x_train_maxsbs = max_abs_scaler.fit_transform(x)
: a" f/ h3 d5 _. l4 b" j7 _. N x_train_maxsbs ( N; c% P0 ^6 H; B. }
# 同理，也可以对新的数据集进行同样的转换 ) {/ i5 |4 _3 Q
x_test = np.array([[-3., -1., 4.]])/ z/ U. t, y4 H* O" Z
x_test_maxabs = max_abs_scaler.transform(x_test)
) Q& x0 w3 U; B0 {# D& w0 ~3 O x_test_maxabs + i6 _+ f! p' Z5 ^2 g, B' ?! F
针对规模化稀疏数据0 H8 a- a7 H0 F6 A1 _
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: B% q% F+ V9 [. g
MaxAbsScaler,和maxabs_scale 3 f* R( i1 \0 L2 |7 s1 v
针对规模化有异常的数据
7 s+ s# h% E- S3 E7 L 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. ! X9 [! C( ^6 ~
正则化Normalization W/ V: P# c# }& ^
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 . e. L. P4 h% g0 t( l; O9 r* V7 R
x_normalized = preprocessing.normalize(x, norm=l2)
; A* ]1 ^( h; m& q print x; w* T+ G( r& T0 e: Q9 h4 x, Z
print x_normalized
6 o5 h& k7 q2 j6 c: }2 U# L9 J: z # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
+ V% q! w9 S7 r normalizer = preprocessing.Normalizer().fit(x)
0 F# Z5 D [3 E$ \! c* n normalizer
6 c) l& a1 v+ l! k* T. J2 w" h # 对训练数据进行正则 # X' m0 y& F+ S4 Y7 b- f
normalizer.transform(x) # `" y# U3 U! f) ~
# 对新的测试数据进行正则 ) {- x0 E1 u: I% d8 I# o
normalizer.transform([[-1., 1., 0.]])
/ z6 k/ X4 [# j I) K- ?. u 二值化: w* F! T+ p) h% W( a: C4 R- j
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
# Z0 \2 G% F; c from sklearn import preprocessing9 \. n1 X, `# c8 S" R
import numpy as np6 p7 s0 A6 Z" v% N% w! n1 |
' x6 y4 Q' m6 F: S; u! C
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
) `5 K% I: X! r+ O( ]" J x = np.array([[1., -1., 2.],* h3 R4 T- |. \0 i
[2., 0., 0.],
& o4 q5 ~/ Q# y% N) l [0., 1., -1.]]). `3 z, C! [ Q" A$ @ _
" u, w( |2 [* X2 P* J
binarizer = preprocessing.Binarizer().fit(x). c9 [# w3 _& I& [" v
binarizer.transform(x)
7 J+ v$ T' B0 ~, P% I: ~1 Y* X
; o8 X9 \7 }, _: o* h' O binarizer = preprocessing.Binarizer(threshold=1.5)
- N! y! E- @ O4 s p binarizer.transform(x) 9 s9 y% D' x5 T
为类别特征编码. _ }3 d3 ^8 D" g
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. 3 \) z5 N, E, H& b, R0 k& o6 A# D: l
OneHotEncoder + o4 I8 W0 s d" Q4 [3 {1 M
弥补缺失数据! h4 b# }. y) O6 I! B
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 2 x1 ?0 U- g, c& W: o
import numpy as np" K% J. U! Q" [8 o! k
from sklearn.preprocessing import Imputer, V$ P1 N& Q6 V; C1 p) [: Z7 R; m
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)7 C U, R" `. k4 Y$ G
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
|- r6 |7 m/ E; ]8 [ B x = [[np.nan, 2], [6, np.nan], [7, 6]]
; T5 U+ z6 b' N% x imp.transform(x) 1 n) p5 P( A& I# r
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
, _' t [0 V" y; u$ e* ~ import scipy.sparse as sp
- a7 _. a* k+ Q1 Y# N6 Y0 W # 创建一个稀疏矩阵: u$ w* B: y, J1 x9 C/ v: k* \
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
, Q8 D, `( R3 K0 {6 k imp = Imputer(missing_values=0, strategy=mean, verbose=0)
; s7 t: {8 l c% z4 @1 V imp.fit domain name is for sale. Inquire now.(x)$ s1 f. H h# M- v' d
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])' i4 F1 j3 Q4 p. G! G4 j0 ]( B" r
imp.transform(x_test)
V$ ^+ n5 r" q4 ?6 q 当我们拿到一批原始的数据
8 I# D! K" s! b 首先要明确有多少特征，哪些是连续的，哪些是类别的。
1 P4 M. r/ `% t 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
) C# @. I2 z$ z7 k3 X: G0 n 对连续的数值型特征进行标准化，使得均值为0，方差为1。
" r( v3 Q) i5 A1 t9 {: ~ c* x 对类别型的特征进行one-hot编码。 d6 s3 n& V# r
将需要转换成类别型数据的连续型数据进行二值化。 - C& R" ~( _8 D ], k1 v9 ?
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 ; U p$ N* x o
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
7 v3 N' e4 {8 k; s 根据实际问题分析是否需要对特征进行相应的函数转换。 ! i E: Y" Z* t8 }+ h; R
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 6 h: i z/ N- a. K) l
因此针对动态的数据可以采用如下几种计算方法: F- k5 l& e% Y2 G( P
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
5 {4 h6 w ]& ], y: a, F
5 ~( E$ b: u1 m9 J2 B: t d% h* R; |! c- f! X' I* R0 W
- t' W! ~+ s+ j, ?
% b( `* ]# Q. b3 \# B; x- b; F$ y |
