|
8 f2 f3 ^8 j6 x3 T# W' f sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
" M# o8 q* @; S" B. K- Z/ X6 t 归一化是标准化的一种方式,
2 n, {, r- j% I% u! d2 u 归一化是将数据映射到[0,1]这个区间中, 2 ?5 y2 B/ W4 Z% T5 g
标准化是将数据按照比例缩放,使之放到一个特定区间中,
9 K' z4 t' T* l( V, [6 `: A+ q 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
( _+ J& x1 g t( z 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
* w3 } k: }$ O4 | s 导入模块:
1 n' ^- J6 l8 \/ \9 o from sklearn.preprocessing import StandardScaler
v" q. p! |2 w from sklearn.preprocessing import MinMaxScaler
# H/ D" }$ X% P! D8 f from matplotlib improt gridspec* k6 d; J0 `( D# ]
import numpy as np
1 Y Y# B, T# j0 X% x/ g import matpotlib.pyplot as plt / V4 B2 Z+ S" f3 s. {
使用sklearn 进行标准化和标准化还原; H9 x" V) A( n
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
! V/ G+ F$ n3 v, Z. T. e std = StandardScaler()
( Z! d- K# y4 U5 M8 m data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]) Z$ ~8 z# @" V- }
& k- a. t, q, d g" L7 B4 h # 将标准化后的数据转换为原始数据。
/ f1 X7 [" h) C8 u0 Z std.inverse_transform()
( M" |: P, C* g3 o 查看标准化后的数据的均值与方差
6 G, ^. E" a/ u1 w$ m: a x_scale.mean(axis=0)# 均值 + F. B9 M) {( |5 b
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
& l* B6 j2 r* M) i$ o+ W x_scale.mean(axis=1) 2 [) o/ Q* y" s4 z4 C7 f
`
! s [ s8 B1 g+ `/ n8 I1 ?7 K4 G* r cps = np.random.random_integers(0, 100, (100, 2))
5 U2 m/ t! K4 i+ W6 e' d/ x& B # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
8 X, p5 X& W c& M ss = StandardScaler()' L8 f6 v z: w* U7 N4 L2 e
std_cps = ss.fit_transform(cps)
4 @. E& r" w% f3 @ c/ V- p gs = gridspec.GridSpec(5,5)/ ~. y$ Q" v0 e% C
fig = plt.figure()
+ ^; y7 |7 I4 ` ax1 = fig.add_subplot(gs[0:2, 1:4])% O" Y' H. H' D' V
ax2 = fig.add_subplot(gs[3:5, 1:4]) w6 \) \. g n% B% T
ax1.scatter(cps[:, 0], cps[:, 1])
$ c+ Q# Q8 S7 o+ u% G; E ax2.scatter(std_cps[:, 0], std_cps[:, 1])
2 B1 c! {' T0 Z+ f plt.show() + x" t4 @5 s* Q1 V. s" |+ \
`
# L4 }* V) ]% s/ O* r) f1 ] from sklearn.preprocessing import StandardScaler& s9 M7 e$ _6 p8 \2 S, C" `4 \
from sklearn.preprocessing import MinMaxScaler2 b( V* O$ T6 U- Q3 v+ n) S
from matplotlib import gridspec
0 Z7 L8 b5 B% N! P( r0 o, W$ A4 v+ f5 U import numpy as np
' I7 H/ q0 M$ J& }, h' K import matplotlib.pyplot as plt
3 f# M- H2 ^. R( Q t data = np.random.uniform(0, 100, 10)[:, np.newaxis]: E* @) x7 M( I6 o6 V# ]
ss = StandardScaler()
1 x" S/ L! d, `$ B std_data = ss.fit_transform(data)
" P" t1 S, x5 z origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据- ?- S! V2 T" q2 G
print(data is 原始数据,data)- T. C2 W; c2 Y/ C
print(after standard 标准化后的数据,std_data)) M' i0 |8 F: [; ?+ ~1 i, U
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data). D" M4 L) ]9 c) p# y7 C
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
# m/ {) _# u0 d. {+ n: j: H 使用sklearn 进行数据的归一化和归一化还原.
' [0 z0 T, g7 P data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
7 v) \ o+ z: F& ]* d5 x' o# ~ mm = MinMaxScaler()# 创建MinMaxScaler 对象
7 @0 o j- H" v: L' f! h! @ mm_data = mm.fit_transform(data) # 归一化数据
) g8 c/ t4 [* U2 |9 ^ origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
' Y5 R1 ?$ i4 ~0 v4 ? print(data is ,data)! I# d8 M1 [/ _$ J0 x! x- ]
print(after Min Max ,mm_data)
* Q& A# H! y$ @! U print(origin data is ,origin_data) 4 t; C( ` n( r% O7 j9 H5 O* k# o
MinMaxScaler和MaxAbsCaler:
9 s) z+ p* W4 H- w5 e- |6 v MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
x7 v* f8 B- U* C MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 * u8 @( m' G' |; s
min_max_scaler = preprocessing.MinMaxScaler()
; X# s8 e+ ^" Z+ r6 I x_minmax = min_max_scaler.fit_transform(x)
6 b& p4 t* G' I x_minmax
5 L* K1 `# N: J$ b& J 对于新进来的数据,采用如下方式进行函数调用:
/ n& m: ~/ J9 f4 D x_test = np.array([[-3., -1., 4.]])
5 p; X4 y6 N( J, g9 z! ?0 C x_test_minmax = min_max_scaler.transform(x_test)
Q/ W1 F* u! Z7 ` Q: q5 ~6 g0 B x_test_minmax
' o9 o9 v9 Q8 h3 A, N MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. 5 Y+ @8 Q6 y1 L: X# t
max_abs_scaler = preprocessing.MaxAbsScaler()3 w) A. m: c1 O' V. T3 q$ R" B
x_train_maxsbs = max_abs_scaler.fit_transform(x)% n' B# W5 q) C8 a
x_train_maxsbs " G" M. s0 c5 U7 H9 D& D
# 同理，也可以对新的数据集进行同样的转换
3 [& p' r, }4 G* S8 V! u- O x_test = np.array([[-3., -1., 4.]])) t3 W+ o. C+ n
x_test_maxabs = max_abs_scaler.transform(x_test)* D( p% x1 x& P$ z
x_test_maxabs
) i' f6 \7 e9 K# X; Y6 }: h 针对规模化稀疏数据
& h) A K( R. I: X5 b1 ^ 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
. L9 g) k$ R0 B) j# t MaxAbsScaler,和maxabs_scale
, M) t; _7 `9 I6 y1 m9 K0 h 针对规模化有异常的数据
- c( h' X6 a) Q( O 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. / Q/ j% t. K% p6 w$ E
正则化Normalization
$ W; J7 m1 s u. F/ \ 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 5 p9 D& g* f: e2 p3 \
x_normalized = preprocessing.normalize(x, norm=l2)
6 m/ r2 }+ P" d g print x+ _& [# E, k. o6 `0 ?8 t
print x_normalized
; F# `" _* I# A0 }; p. a2 K # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) 2 E. e( J* C1 ]* y `+ x3 w7 i
normalizer = preprocessing.Normalizer().fit(x): k! t' ^5 w8 J5 O9 X( g5 U7 j
normalizer
. c; C) B# a! g' w! y # 对训练数据进行正则 % g2 X u: W' v3 A8 H3 s' t: m7 w
normalizer.transform(x) 9 S; u; j: H: G$ t7 X5 m* U1 v5 t
# 对新的测试数据进行正则
8 E7 O% k8 X' X' U* _- k' @4 ? normalizer.transform([[-1., 1., 0.]])
- `( l/ p, \- C% q/ v3 M* V0 S 二值化
; E0 ~% W' V' {5 E8 f% W8 ~ 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 7 t# Y0 p' T7 L
from sklearn import preprocessing+ |4 d, P& m0 k' H
import numpy as np
8 E: ~; k* @. V9 ^2 i! h& J* o1 X
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征. L& a0 q( W6 P% \) S8 I& e
x = np.array([[1., -1., 2.],# {! D5 y' Q( q- x
[2., 0., 0.],: _3 @: R0 w% S. Y8 A/ t, q% `. l
[0., 1., -1.]])
! S3 }( c. P' X* ], m4 f4 d* ^& J3 N" m' Q$ e$ [
binarizer = preprocessing.Binarizer().fit(x), {8 M& L& z4 W+ ~
binarizer.transform(x)
4 T; @1 e5 l1 i0 z
3 k+ b# k' [ v2 ?( Y binarizer = preprocessing.Binarizer(threshold=1.5) S" A3 o: X# x: I' V
binarizer.transform(x) ! u6 p" t( i3 P2 q
为类别特征编码
- j" n( f( b7 C (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. , F$ z1 [) Y$ u8 g* G
OneHotEncoder
) z) m1 O f$ E 弥补缺失数据
/ B5 @# `5 d2 E8 ^: `$ q- { 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
$ R( R! E; R y7 j5 |# K import numpy as np$ {4 S; G. t+ s# d( S
from sklearn.preprocessing import Imputer! v' v8 t9 Y0 G, F) I
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)& m- f; ?9 ?2 W5 T$ Q
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
( F1 n. f0 W' d8 f% [ x = [[np.nan, 2], [6, np.nan], [7, 6]]. O: e# |0 J- h! C
imp.transform(x)
5 X, q: m) p& G7 V1 i& o0 V: H. c Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
7 V! O+ Z B, H$ l+ V/ ? import scipy.sparse as sp) P4 d6 r x; v j: L
# 创建一个稀疏矩阵0 [( Q6 Z* ^( z9 f/ \* Q
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])+ a+ x2 g! s( W) C1 [1 ^
imp = Imputer(missing_values=0, strategy=mean, verbose=0)6 ]% s4 ]+ w5 J
imp.fit domain name is for sale. Inquire now.(x)- b- d$ y4 n3 T: @. ]( `- [# s% z
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
7 S- ^; c% F* Q8 D! }; P: E* V( C% e imp.transform(x_test)
7 a) x! N3 T0 t( H9 A, ` 当我们拿到一批原始的数据
% F8 v g! i/ r8 u# k5 r 首先要明确有多少特征，哪些是连续的，哪些是类别的。
% O* p0 I. Z5 @/ [, A 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 6 W* ]. E* e/ K& d$ `4 g* S
对连续的数值型特征进行标准化，使得均值为0，方差为1。 ! g: e. `* d. M& }
对类别型的特征进行one-hot编码。 ' r8 O) o) ?3 M
将需要转换成类别型数据的连续型数据进行二值化。 2 _+ v$ L8 u% j8 @% ?* ~
为防止过拟合或者其他原因，选择是否要将数据进行正则化。
6 S: v, Y1 N; v/ B8 i 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 3 c4 E$ p6 S f
根据实际问题分析是否需要对特征进行相应的函数转换。 , H2 S1 P3 W4 c3 e; v" {
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 * q. K7 S S/ `) {3 Z
因此针对动态的数据可以采用如下几种计算方法:
# c, G0 G) Y' ?4 D 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 # U8 A% x* |8 Q5 ?5 d' z& g
: T: ]6 h* w" e/ t4 w- g+ i9 C5 w/ H/ ]2 z9 m- {
4 H% H* p) J; l" t7 A* x; N, X6 X
+ ~; k( W7 l4 O
| 
