|
b; w8 P ?4 O1 x9 ]; j sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
+ `3 S( `6 [6 U8 {, E! j% F6 s 归一化是标准化的一种方式, & S+ T3 ~5 ^' W
归一化是将数据映射到[0,1]这个区间中,
/ x' J S* r9 x. U4 J 标准化是将数据按照比例缩放,使之放到一个特定区间中, " `7 D! k( m% S) N& N. O; K
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
( ~ n [: ]) I$ }* r9 F 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
5 i* v/ |1 K0 W0 m4 V 导入模块:
: t0 E8 ]" G5 y+ {8 u9 i# ` from sklearn.preprocessing import StandardScaler
3 @5 B6 E0 J8 H from sklearn.preprocessing import MinMaxScaler
8 {. W! [. d+ {$ W from matplotlib improt gridspec
5 m3 A% ?2 U3 V! j3 ]3 g import numpy as np
6 c' X/ c7 P1 m. H" c0 u import matpotlib.pyplot as plt
# R% _( B# D* { 使用sklearn 进行标准化和标准化还原
S. X# L: C7 {0 P8 q9 t 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x) 9 E3 C# L* M% I7 \8 f( E
std = StandardScaler()
# A- U9 W$ S. ~( M9 f# `9 } data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])5 |! L4 W% c; ^
, Q% y( Y( g$ L2 W& H! B* W
# 将标准化后的数据转换为原始数据。/ X: r2 {9 b! K: K k* n6 [
std.inverse_transform() , y8 k5 v0 }/ d- H y
查看标准化后的数据的均值与方差 $ c7 [! O- V1 M$ |$ e) J1 i4 _
x_scale.mean(axis=0)# 均值
( n& h7 U! q% P2 n # axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作 ( P2 F6 c( g3 B+ z6 d: m1 T) h
x_scale.mean(axis=1)
* n+ H1 J/ Z" I8 I8 R ` # { I) j- w* R7 J5 ? H9 t
cps = np.random.random_integers(0, 100, (100, 2))
3 }7 W7 Q; P9 T X4 S" j( P # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集. M1 h: Y" O2 [
ss = StandardScaler()
5 Q% D; ?( h: c7 B1 }+ { std_cps = ss.fit_transform(cps)
. r5 c6 k3 q+ q# t7 m& e gs = gridspec.GridSpec(5,5)9 k2 K# y( ]( X3 ?- y) A) v: ?1 `2 y
fig = plt.figure()
7 s, ^0 C7 s) l9 y ax1 = fig.add_subplot(gs[0:2, 1:4])* H3 ~4 j7 L0 S% R& v7 u) X1 }3 |
ax2 = fig.add_subplot(gs[3:5, 1:4])
( v# @9 B; h* \% [ ax1.scatter(cps[:, 0], cps[:, 1])
b7 b9 ?9 L7 K ax2.scatter(std_cps[:, 0], std_cps[:, 1])
# v. b5 o; d7 ~% o plt.show() ; I9 L I! y, g+ R2 G: M
` 2 i9 F8 [: p/ m6 j. C
from sklearn.preprocessing import StandardScaler, ]1 p$ Q% w& q. V
from sklearn.preprocessing import MinMaxScaler
/ Z6 e7 g, d" ~* T9 @ from matplotlib import gridspec) \* r; o0 C; S+ J$ h
import numpy as np5 x- r7 |6 n) \: |% e/ ?
import matplotlib.pyplot as plt
; S4 d( G9 C0 X7 M data = np.random.uniform(0, 100, 10)[:, np.newaxis]; `5 b5 [3 v e i4 t
ss = StandardScaler()
. ?! |/ M3 a+ [, I7 u! ]6 g std_data = ss.fit_transform(data)
8 @' i& r$ g$ H( T* L. m origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
" B) z! m. }$ e print(data is 原始数据,data)
9 z1 M) G5 |& s+ d3 V) t print(after standard 标准化后的数据,std_data)
/ j2 x3 x0 c! l7 |. } X5 M print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)7 Y* X9 \8 \, K2 s! j( N% P; h8 E! u
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) . q4 X7 A. N2 ]8 [0 e" V
使用sklearn 进行数据的归一化和归一化还原.: f8 u1 ~) t) G5 q* y
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
% `( f+ {1 I& v, \ mm = MinMaxScaler()# 创建MinMaxScaler 对象
( H& n2 b7 G( A; L# |( m U mm_data = mm.fit_transform(data) # 归一化数据2 Z0 |- |! R) }- d
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据& s" E* H" o4 ~3 E- p
print(data is ,data)
; k) ^6 S, F6 H- p% c( v* t5 x- n print(after Min Max ,mm_data)
' x8 J0 z+ i: \9 e, _: f print(origin data is ,origin_data)
3 t1 p' F) q4 H/ ~ MinMaxScaler和MaxAbsCaler:
( M$ h' ^* G8 w6 u8 F) i w MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
6 G; g7 n# L$ ]; V% J, I- a9 d MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
( e3 b; P/ ^' r5 }$ ^ min_max_scaler = preprocessing.MinMaxScaler()
, k. A" Q& Z* M x_minmax = min_max_scaler.fit_transform(x)1 g% C' s' k5 W
x_minmax / Z9 ^& O# L9 ?7 W4 @& R1 }5 o
对于新进来的数据,采用如下方式进行函数调用: ' I5 H4 R! I) `# X4 T( `
x_test = np.array([[-3., -1., 4.]])
$ e' i' b+ R# ^4 D x_test_minmax = min_max_scaler.transform(x_test)& T( J% r: ~9 t" A% n# w
x_test_minmax
7 I" f: p6 ~& x0 ] MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
4 t) y6 t2 l( _1 v. g7 G! y% I( W max_abs_scaler = preprocessing.MaxAbsScaler()
3 {/ Y* }, a0 G; F2 M x_train_maxsbs = max_abs_scaler.fit_transform(x)* W0 B- y2 Y3 f% {# }
x_train_maxsbs
3 O- K; ?1 ^' y) A5 L # 同理,也可以对新的数据集进行同样的转换
/ ?! j( A0 W' e% U# a" y2 z% [ x_test = np.array([[-3., -1., 4.]])
. N" @5 w" D* [2 T9 K; [ x_test_maxabs = max_abs_scaler.transform(x_test)4 f# |8 i4 H9 r- P
x_test_maxabs " b6 j3 a, X, F1 a
针对规模化稀疏数据
+ I" e8 E, T. x6 `. G 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: ' H( l" H2 M8 ?& M
MaxAbsScaler,和maxabs_scale
1 h2 s9 a( L9 B) Z1 Q1 z1 M 针对规模化有异常的数据
% N6 r- y5 V3 D( v' \+ k, V3 |8 W 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
9 [# \/ M9 Z0 N. b 正则化Normalization% s1 P: G- d& V
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
) `5 a/ R* X5 I& } C$ V x_normalized = preprocessing.normalize(x, norm=l2)
7 ], t6 B; D' ^$ \: U/ S. l) i- M print x! X8 T- K0 H. D% M/ |6 `
print x_normalized $ F5 Q0 F" M/ D( H
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) 1 m# N! [1 k! d, ]2 S1 N! s
normalizer = preprocessing.Normalizer().fit(x): R# {. X- o( a: [( ^! G+ s0 _) L& X
normalizer * b3 H. {6 Y: Q4 q
# 对训练数据进行正则 5 s/ }- r/ V' o. u/ D* ] D) [2 k
normalizer.transform(x) 4 L; R! Z7 H6 A& e+ V
# 对新的测试数据进行正则 2 T* N: G4 n3 y% P ?
normalizer.transform([[-1., 1., 0.]]) : R: U$ M7 A' j
二值化, s( Q" ^% a; z
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 ! R: ~+ H3 ^; z2 t" h2 {- Q
from sklearn import preprocessing, H+ L \6 O; r6 y/ {5 H8 ]
import numpy as np+ ^2 Q! c1 X) U- W4 w
- Z* f* b8 |7 S a7 v+ B # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征
4 }* o) L) h% b& O7 Z9 W) ? x = np.array([[1., -1., 2.],' X5 i& I5 }( j5 r5 ~: Z
[2., 0., 0.]," Z1 P0 @9 y, ]" ]% B
[0., 1., -1.]])
+ A9 e# B+ w# c$ F5 }$ ^2 T5 q% I' v6 M7 u3 j- s1 E z5 W
binarizer = preprocessing.Binarizer().fit(x)
. d6 k; B6 \- ~0 g binarizer.transform(x)
( y) }3 i M. _+ W$ l5 ^' P! ?, B6 A4 n b8 D
binarizer = preprocessing.Binarizer(threshold=1.5)
/ z6 t# J. ~, i& Q binarizer.transform(x) # q5 h& O/ d. s7 r
为类别特征编码
( [3 N* Q1 c3 w) j6 C0 e (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
! d9 _6 C, I; M+ z& b' P' | OneHotEncoder
1 ~) J- I& Y" \6 t6 u 弥补缺失数据/ M9 m$ t5 O- u: c1 F
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
- p/ Y" ?4 u, m" F; h# ` import numpy as np8 G$ N$ d3 {6 u
from sklearn.preprocessing import Imputer) Y' G# M3 e( O( N* S( S
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
9 {+ W, q. c9 t. x) F imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])+ ^" G+ N7 ]+ O7 l# k; V
x = [[np.nan, 2], [6, np.nan], [7, 6]]! g$ Y1 o9 |/ ]
imp.transform(x) : a$ M6 I6 Y/ O6 L7 p2 d0 k
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值
+ t- C4 W/ S& M$ W$ A4 S import scipy.sparse as sp
# O/ n7 g' t- b # 创建一个稀疏矩阵
! b! ~0 q$ N' W+ M+ O- f5 }: a x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
7 k, A2 u; C/ a) S/ m3 a) j imp = Imputer(missing_values=0, strategy=mean, verbose=0); {; u6 v- e7 @! {- j0 J! K0 W$ Y
imp.fit domain name is for sale. Inquire now.(x)
, v$ x8 Z# A/ B: f1 Q& W5 X' j; J x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])8 P, q8 p1 ?8 {4 E- Q( c# e4 N4 ?
imp.transform(x_test) : X/ q! e1 P5 y# `; [
当我们拿到一批原始的数据
4 E3 p) p8 f% `( _* A 首先要明确有多少特征,哪些是连续的,哪些是类别的。 4 l8 {7 L3 G6 G0 {! k0 W
检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。
4 ~5 f7 D' f2 G 对连续的数值型特征进行标准化,使得均值为0,方差为1。
* _ i: i4 i8 b$ h1 l; U# n- v 对类别型的特征进行one-hot编码。
/ r$ l, t/ \: R# K; ^ 将需要转换成类别型数据的连续型数据进行二值化。
/ w/ S3 \ n0 l/ z0 V5 G 为防止过拟合或者其他原因,选择是否要将数据进行正则化。 6 v* b0 F& o6 A0 C! d
在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。
. S7 U# f1 R/ ?* X& ^* \( D" K3 P 根据实际问题分析是否需要对特征进行相应的函数转换。 * b8 J, G- `8 v
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
3 H0 ^. J, a: E1 P 因此针对动态的数据可以采用如下几种计算方法: 0 f9 H; P0 d5 v& @
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客 + F) W( s, ^4 z* K
' a5 k {1 m0 g: h8 f! X
: t2 h$ ]& }1 e" X
3 L: \4 w& F. v0 V2 U. {
; ^1 y& p% J6 e5 l* B8 @ |