|
+ A8 g( e! C" u4 U9 c" o5 o
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
' V( t- e$ ? i- E( A 归一化是标准化的一种方式, # U g S9 q7 o; |! ~4 ]
归一化是将数据映射到[0,1]这个区间中,
6 F: A5 ^ P3 W5 M 标准化是将数据按照比例缩放,使之放到一个特定区间中, 2 M/ `( k a. r* L$ @
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
. x! Y m( A/ i* k1 @ 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
( }* l V0 Y2 i 导入模块: : I. z$ g4 U* q$ A, q
from sklearn.preprocessing import StandardScaler/ |. p$ S- c# i) h2 z( P) H
from sklearn.preprocessing import MinMaxScaler: v, `2 a+ H8 ^2 b$ n3 v
from matplotlib improt gridspec
1 G& r5 B9 f. \) l) h* V# I8 u import numpy as np
3 [! m* [* x1 P: a0 L2 ? import matpotlib.pyplot as plt \/ J7 |% `! |* z0 ^
使用sklearn 进行标准化和标准化还原
, L O: T1 I0 A1 |3 x! X* ^ 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x) 0 V* @" S+ c, `* C; u# b
std = StandardScaler()
# l! |( I3 P8 e- I5 L+ u$ _* v data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
- o& v( D: u8 Q3 {. ]8 ?
! V- ~: V( ?. ~$ `/ f0 J # 将标准化后的数据转换为原始数据。
/ O ?% f% l# w. o0 X6 ~5 N std.inverse_transform()
3 f: X( E; Z( S6 n 查看标准化后的数据的均值与方差 4 ^7 Q) n$ W0 D t
x_scale.mean(axis=0)# 均值 0 K; Q- j/ |$ B: V3 p& N9 f1 `
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 1 V" J: Y+ ^6 L+ `
x_scale.mean(axis=1) ; k2 z. l& I8 ?$ G! I
` # a$ l4 E0 N$ ?+ U' R3 U
cps = np.random.random_integers(0, 100, (100, 2))
0 v1 v6 P$ a/ | a # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
7 F5 K1 s% u2 J( H1 R! c: ? ss = StandardScaler(): Q) b1 B/ l6 n! h* p% V
std_cps = ss.fit_transform(cps)
q) z8 ]7 l& o( u# W. ` gs = gridspec.GridSpec(5,5)
$ f7 r4 B* n1 \8 s1 A2 H0 F. s fig = plt.figure()5 ?4 w& h. f# Y& f6 m0 Y/ c$ e
ax1 = fig.add_subplot(gs[0:2, 1:4])
7 W- R- L# e3 `& w$ B ax2 = fig.add_subplot(gs[3:5, 1:4])
: H r5 c V4 b( S3 m! v x8 \' T ax1.scatter(cps[:, 0], cps[:, 1])
5 g: R+ r2 E* D2 D3 | ax2.scatter(std_cps[:, 0], std_cps[:, 1])
0 u7 I- ^) K* W plt.show() ( \. [& v9 x, d8 x. e
`
2 s( q0 g" U% \; T' U from sklearn.preprocessing import StandardScaler0 T. S) F/ X1 O* n& \$ x
from sklearn.preprocessing import MinMaxScaler
, r* ?4 X7 ~( X$ y from matplotlib import gridspec% J5 ?' A7 _- V3 L# Z' L! c$ n1 Y
import numpy as np9 o5 H. r9 Z$ c8 w
import matplotlib.pyplot as plt
+ l* B7 T# p' Q' R$ w8 k9 O5 } data = np.random.uniform(0, 100, 10)[:, np.newaxis]
0 W: [4 O1 r5 U9 U2 j7 X9 [ ss = StandardScaler()5 L% g# S' H3 v0 _% A# K& [/ q7 P% _
std_data = ss.fit_transform(data)* l8 d' r+ y( F; ^/ L& a
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据6 l2 J. s# w5 D# G
print(data is 原始数据,data)0 S+ C8 d8 P+ W# v7 ~1 \3 d
print(after standard 标准化后的数据,std_data)
& y$ z7 e+ P& O- B) ^' ]6 w, S* S print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
0 A. a/ v* L9 v* l g# J print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
( q) r7 @0 O. s* l! s4 K2 C 使用sklearn 进行数据的归一化和归一化还原.
* S( t. `2 g7 R) `5 @ data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
* c. F$ d; U7 i: @0 l mm = MinMaxScaler()# 创建MinMaxScaler 对象
1 J U) o7 F7 r3 T3 C mm_data = mm.fit_transform(data) # 归一化数据
' b* O1 u8 _: h1 z8 W origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
/ Y0 `7 l$ S) H- T3 h0 G print(data is ,data)
( a& _, Q! a: b6 f, ^ print(after Min Max ,mm_data): L- _5 m& x5 z" Q' f9 A6 z+ E; I
print(origin data is ,origin_data)
* l* Q" J' A0 X& E MinMaxScaler和MaxAbsCaler:
5 S* W7 q& s. c0 m0 D MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) H3 M: ]' ]$ y: S8 E' j- G
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
( h1 c) j: x7 i min_max_scaler = preprocessing.MinMaxScaler()
( x$ X2 D) b. m3 y5 t+ T x_minmax = min_max_scaler.fit_transform(x) k1 x. |) i9 l% F u
x_minmax
% l" u* q8 f" J) G. u$ ^ 对于新进来的数据,采用如下方式进行函数调用:
F: n! i" A3 _( w9 x9 Z# U x_test = np.array([[-3., -1., 4.]])) [8 q7 U% O6 a9 ^7 X
x_test_minmax = min_max_scaler.transform(x_test)' o' i& x1 O) X2 `, z i
x_test_minmax ; O6 T" O7 h* Q; q) [( m- Y' I
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. / q) v& D% a8 D% n# W) B
max_abs_scaler = preprocessing.MaxAbsScaler(): H0 x- s* i0 R7 z3 I" e. Z- z$ h; [( o
x_train_maxsbs = max_abs_scaler.fit_transform(x)
, B9 C) c) K) c7 y* {$ i x_train_maxsbs ) Q# A- g: ?5 B# q: A
# 同理，也可以对新的数据集进行同样的转换
# ^7 q: z+ R4 b2 u7 o! C x_test = np.array([[-3., -1., 4.]])
8 t- b# F, q- b1 g$ ^) D x_test_maxabs = max_abs_scaler.transform(x_test), y! `. q' C4 K8 B8 |2 f0 r6 h
x_test_maxabs ) w9 M5 P4 x9 x4 W) v
针对规模化稀疏数据
9 f$ W1 a/ M" ] 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: * C3 w1 E0 [; B+ F( L+ K4 Q, f
MaxAbsScaler,和maxabs_scale 0 A7 h3 g+ M% @% H: h2 o7 ?" v
针对规模化有异常的数据
: |. t8 x9 _# k b3 F% ` 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. 3 A( |! x9 u4 K/ y q b
正则化Normalization
+ n c; ~# r, Y' }. M) @ 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 * C% A0 r/ p2 e' j$ I1 C
x_normalized = preprocessing.normalize(x, norm=l2)
) }$ b% \. h$ B print x
! z/ n4 a3 q( F- g# d* A print x_normalized
- w7 L+ V [% N # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
( ?& V7 K, f! I. Y normalizer = preprocessing.Normalizer().fit(x)$ r# |1 P! l* O% s0 Z3 _
normalizer 5 P" g: Y% i. H( `# R7 Z) C
# 对训练数据进行正则
9 y T2 J2 X `2 G) s, C% B+ o normalizer.transform(x)
3 U/ o8 t, x% }& L( D& m # 对新的测试数据进行正则
8 w; Q5 l" S. T0 u4 O+ m normalizer.transform([[-1., 1., 0.]])
4 r! `- g! n5 Q 二值化
* p R2 b* e. T5 ^5 _! h" l 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
: Y3 L0 ]; e- p; J& d! y from sklearn import preprocessing
0 A; o3 s. |2 t import numpy as np
M; C( Z0 F( f$ z- x% Q, `! b6 ~) m) _
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
" Y1 B- k0 u; ^$ Q2 ?. j( @ x = np.array([[1., -1., 2.],6 Z, j& Q& S/ p% r! r. u
[2., 0., 0.],
1 o# e" D7 k4 i* j# ~4 _7 n" Y [0., 1., -1.]])" [5 X* j5 a: W# |) N$ {
( D) b. G9 U. g: X4 }/ _- p/ \
binarizer = preprocessing.Binarizer().fit(x); w1 @7 Y# ~9 g
binarizer.transform(x)
1 G( _! l W) N( X7 X; I4 J& T5 r$ n! A5 {7 g) G
binarizer = preprocessing.Binarizer(threshold=1.5)" [0 T5 ]5 | E' X; V+ u/ j
binarizer.transform(x)
) w: E$ O( K9 T1 u! j 为类别特征编码
V6 W4 o0 x. T9 q# Q4 g% @ (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. % b9 z- l) L3 ~1 d3 g$ @
OneHotEncoder
) i4 B3 I5 G9 _2 S# j" ` 弥补缺失数据
% N, Z8 V; M# R; ^5 w5 @ 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
2 w# r+ }+ n. ?+ j" i import numpy as np
/ p/ H( m" q5 J! g" o. T from sklearn.preprocessing import Imputer
. e1 ?! x3 b: g, [9 v imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
/ f% i# J- I3 |! F) ~: \ imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
% T9 }9 C* B+ j# r- j9 k1 Q x = [[np.nan, 2], [6, np.nan], [7, 6]]
* t5 ~: p% G. B- g imp.transform(x)
* o. A/ n% }3 x0 w3 Q6 F1 s Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
8 V6 u, @) L0 r9 Z9 D' W import scipy.sparse as sp
+ K; }: X- n `/ o( u # 创建一个稀疏矩阵
: O7 Q0 P; S3 |# J/ V x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])/ j; ]8 e- K. Z& ~( q5 W1 ?: ^
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
7 [- T- Y* m, | imp.fit domain name is for sale. Inquire now.(x); T O- w. x7 K6 g
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])$ W5 W/ P" E. }9 {
imp.transform(x_test)
2 o, A8 P& b9 n) N1 p" T 当我们拿到一批原始的数据
6 L- R K; d) V. W$ L5 f* s. K* G/ t2 n 首先要明确有多少特征，哪些是连续的，哪些是类别的。
- T/ `' r- f! o; } 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 . x6 b% P i& L! I% C- l
对连续的数值型特征进行标准化，使得均值为0，方差为1。
4 f; a; p& B& T! \6 D5 F; [ 对类别型的特征进行one-hot编码。 1 S3 W% Q+ m, W: I1 i |# L
将需要转换成类别型数据的连续型数据进行二值化。
! i Q; F/ R* x& w) W# v4 i* @ 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 ) `# E; t* E" @( w& |. \
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 6 @/ @' A8 k, o5 R d
根据实际问题分析是否需要对特征进行相应的函数转换。
% z) W2 Z- Z& W4 u7 L2 h) h 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 0 x7 _8 |8 c1 @# I4 G
因此针对动态的数据可以采用如下几种计算方法: ) G8 L) j G$ f- f! ~$ `( V. ~
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
, ^2 d3 V; @3 r1 g8 h- o
; H. \/ T: u- _% h
/ a0 ^) S; w+ n: K8 E
0 r, J: T K) r. d) I$ i
1 H' I6 y, Z3 R7 p | 
