|
5 E: x9 L. {! f2 ~$ u. J sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
) {8 D! ]! @7 h8 o! t- |) y, O# _ 归一化是标准化的一种方式,
, w) l- ~3 L8 }* b$ r8 Q X 归一化是将数据映射到[0,1]这个区间中,
9 j3 t# K5 x _ 标准化是将数据按照比例缩放,使之放到一个特定区间中,
. W1 {! X* |* A" j" `: b 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
* R. ?- L6 @* f3 m3 g6 w8 U3 n 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
5 p; a& n1 I: H4 x 导入模块:
* J4 X) T/ \- U, @ from sklearn.preprocessing import StandardScaler
3 @+ L( I7 h$ ?" l from sklearn.preprocessing import MinMaxScaler) V. ]6 r' G* ~( X2 f3 X* }2 |. f
from matplotlib improt gridspec
- ~! L# ~8 V/ B6 l1 H k import numpy as np
. U, w3 q* V2 H' z( W( ` i' k% u import matpotlib.pyplot as plt
( B/ t7 ^6 O8 U+ C w) }9 ]- p4 r3 c 使用sklearn 进行标准化和标准化还原
; b& z+ D2 M% E& i( g 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
& i2 A7 j) @+ {* L1 K std = StandardScaler()
6 i% Q& t2 ]) V data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
\' S6 V C4 ~7 Q3 z7 H `+ v# ]/ z
# 将标准化后的数据转换为原始数据。
8 E$ \: Z2 W f/ q, ]/ r) ? x std.inverse_transform()
: Q" q% q7 @7 N2 e; H3 b 查看标准化后的数据的均值与方差 $ Y5 f4 w1 K! K! _1 F3 m) v; `
x_scale.mean(axis=0)# 均值 5 O7 f5 h# g" F* B5 O! Z+ G7 D
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
, Z# j5 \) d' \5 J x_scale.mean(axis=1) 9 t" j$ d8 `8 k8 X# W2 Z
` 0 N1 k% n( f# P1 q4 a, `
cps = np.random.random_integers(0, 100, (100, 2))
# Q7 ]1 b, a) U( g # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
, A0 u0 H/ s* U# o ss = StandardScaler()
" i; j1 u1 z8 \8 X! Q- d- Y4 x std_cps = ss.fit_transform(cps)% `4 o- w" }. Z* ^ ^
gs = gridspec.GridSpec(5,5)
; O+ k8 c: l! l8 J0 N fig = plt.figure()& s# ~2 J4 t3 Q
ax1 = fig.add_subplot(gs[0:2, 1:4])
2 f1 H* _8 b9 ?. l ax2 = fig.add_subplot(gs[3:5, 1:4])* B3 V8 H* k8 B7 K. E' d' O9 a; O7 a
ax1.scatter(cps[:, 0], cps[:, 1])
* i- B' w, g; Q, N ax2.scatter(std_cps[:, 0], std_cps[:, 1])/ N( i$ `' Q; H5 g7 `! f
plt.show() 2 Z; s4 C h6 S+ N% O
` w$ [* n* t, {. u/ G
from sklearn.preprocessing import StandardScaler
# N( k$ U* S( f2 k1 ^# m; ` from sklearn.preprocessing import MinMaxScaler6 Y3 W+ Z# B2 p5 O' C
from matplotlib import gridspec9 I. d- d& h* t7 [* u
import numpy as np
/ g" i* \' ~# H; d import matplotlib.pyplot as plt
7 E- s0 K" I* K4 l( [4 l p data = np.random.uniform(0, 100, 10)[:, np.newaxis]9 f- t( [+ W* p& R2 y b+ Z
ss = StandardScaler()
1 P; l; Z7 l d# j6 K) i) X! c std_data = ss.fit_transform(data)' ?4 ^7 l/ W7 J- U" C; F
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据' O4 a) x U. M
print(data is 原始数据,data)1 Z8 @! z* i' Z' e
print(after standard 标准化后的数据,std_data)
& V; H0 L4 M# ?* P2 j print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)$ W! y% C2 B: n" j1 D5 F8 L! c
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) % G$ l. c/ A$ g/ m) W& E1 j
使用sklearn 进行数据的归一化和归一化还原.1 `: s# X; m- j
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
8 K/ ^' s1 a6 @$ } mm = MinMaxScaler()# 创建MinMaxScaler 对象
3 R9 u6 @: W; Y( T1 W$ { mm_data = mm.fit_transform(data) # 归一化数据
, K: B N/ I# o$ j: h origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
' t1 q. C* j, A3 ` print(data is ,data)' t* [% c9 e& d! _9 ?) I
print(after Min Max ,mm_data)
: n$ `/ j1 A& `- K8 M e. W) f [% E print(origin data is ,origin_data)
) `. L! f4 q' L8 {# A; } MinMaxScaler和MaxAbsCaler:
' ^' B9 f$ G0 [3 n1 I MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) e: |" X3 |, y" ]% f. o3 ^
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 4 x2 ~9 t) T& |3 i4 i$ z
min_max_scaler = preprocessing.MinMaxScaler()
5 W6 p) ~' p# ]6 e! }' T x_minmax = min_max_scaler.fit_transform(x)7 _ p. y9 O( w5 v. @
x_minmax 7 T9 q8 T+ [3 C8 f8 Q
对于新进来的数据,采用如下方式进行函数调用: . P& U- O9 y& v) S) N9 A
x_test = np.array([[-3., -1., 4.]])/ D) z A3 k3 y2 d% l
x_test_minmax = min_max_scaler.transform(x_test). ]3 H4 Q9 i% [1 |3 @) o/ C6 E" l
x_test_minmax
8 X4 ?) [2 s' I; s MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. 5 a. c' p8 F K* q& }- M% l& M
max_abs_scaler = preprocessing.MaxAbsScaler()- Q3 z4 u7 K* J/ x: _
x_train_maxsbs = max_abs_scaler.fit_transform(x)% k% r& O/ e) Q. T' ]6 q/ C
x_train_maxsbs 5 m g( ^# M. z+ y. s+ b
# 同理，也可以对新的数据集进行同样的转换
# ?! K% b1 r( G4 C U$ p x_test = np.array([[-3., -1., 4.]])6 f/ T+ H" Q$ ~% m* A; Z1 i
x_test_maxabs = max_abs_scaler.transform(x_test)
1 b, U" \* z6 B x_test_maxabs
F/ q7 g( C$ r 针对规模化稀疏数据
! @0 U! T4 |* k$ v2 D/ \6 L7 _ 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: * U3 }% a O# }
MaxAbsScaler,和maxabs_scale
( a9 t: H3 ~7 b" v 针对规模化有异常的数据0 `, m2 e! F! q
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
1 B7 n {! j9 { P 正则化Normalization( b& x; y7 q- i# `& a+ T
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
3 s7 s: s1 @$ B# Z x_normalized = preprocessing.normalize(x, norm=l2)
; X0 U; a: |- W9 P7 u print x
+ z7 Z# C0 E7 f, K print x_normalized
+ [) t# }6 y' `" M" t9 k # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
4 b, L" a7 ~9 L# x. A" e normalizer = preprocessing.Normalizer().fit(x)4 O$ }0 u9 A. \) s6 |2 {9 {' T
normalizer ' C0 m8 n/ H& f7 R9 N
# 对训练数据进行正则
* y6 `! u6 r; g, r" g# \; d! C! Y normalizer.transform(x)
# m8 C" x2 q0 a # 对新的测试数据进行正则 $ C' d$ l5 O- a$ q. T" S
normalizer.transform([[-1., 1., 0.]]) 1 u7 }7 q4 h" j$ B: A- f& c
二值化" k& B2 ^* P- v
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
) e" }- S- p7 n2 z$ ]/ l from sklearn import preprocessing. S: I! U" \6 e+ B0 v9 m
import numpy as np [* B, p$ a9 Q% G5 S x6 N9 r3 V" [
0 r8 V* \) d, v8 S# J
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征7 s0 f2 s" m! \4 x* l T9 d- v2 f6 q
x = np.array([[1., -1., 2.],
8 d* d2 q5 t& O5 z9 o9 r [2., 0., 0.],
5 A& z5 V' T" o9 b" U- D$ o [0., 1., -1.]])
$ W+ m/ Y$ p+ j9 N* n. C# {% ]# j4 t! [ Y: q
binarizer = preprocessing.Binarizer().fit(x)( Y% q2 N! I9 @: ^
binarizer.transform(x)7 V" [* e" O2 |
6 ~3 g4 N. a% G binarizer = preprocessing.Binarizer(threshold=1.5)# Y$ k0 X$ H8 B" N+ \
binarizer.transform(x)
1 Q/ L5 V) k" o 为类别特征编码
5 F+ Q! w0 _7 G5 p& G3 n O (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. A" R8 y5 g* n! v4 H! c$ L
OneHotEncoder / g/ R+ p/ o+ z. ^6 b. H% w
弥补缺失数据
3 u9 r: I/ _4 g' i* v 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. / Z# K4 r+ @4 V! u. j2 W
import numpy as np
$ d j! I( Y- r( I2 @6 h from sklearn.preprocessing import Imputer
: m; Q6 g" O* ?% `3 i0 J5 k imp = Imputer(missing_values=NaN, strategy=mean, axis=0); ]$ ?1 l4 Z v) J0 ^& U7 \
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])' {' o- v4 j7 i! h& [/ ~% T
x = [[np.nan, 2], [6, np.nan], [7, 6]]
6 G* J- r7 {! }+ l+ p imp.transform(x) * D( L7 B: { `# ^3 Z V+ T
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 2 F$ l4 K; j, P( t* V0 m/ Z7 c
import scipy.sparse as sp6 Q% m$ u b' G
# 创建一个稀疏矩阵
0 m2 a7 }" e% z$ z( e# }- C, N( ~& e x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])7 l; A3 Y* ?' ^ @* [5 v
imp = Imputer(missing_values=0, strategy=mean, verbose=0)) S: E, `) K1 B2 {1 y
imp.fit domain name is for sale. Inquire now.(x)
6 X" R5 b% w& F8 F! U. H x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])# ]0 }4 [& H4 R/ L0 j" N, X0 ?! T
imp.transform(x_test) . f; D# |/ [1 m3 n2 h9 \
当我们拿到一批原始的数据
, S. c) Z+ [5 ?) X/ B& r; \! |% k 首先要明确有多少特征，哪些是连续的，哪些是类别的。 ; S3 \ J% K# l' c
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 ! R: c! u5 Q1 R6 Y$ g& v
对连续的数值型特征进行标准化，使得均值为0，方差为1。 ! P" u* ?* `4 ?: p$ \( d+ d, B& L+ K
对类别型的特征进行one-hot编码。 - B l3 J; j) H: U `3 ?: z
将需要转换成类别型数据的连续型数据进行二值化。 - x- w1 _/ O! c$ s8 `
为防止过拟合或者其他原因，选择是否要将数据进行正则化。
) Y& g2 |! ]$ Y# O( q" ]! t 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 : u5 v/ {- l: f j, P8 L
根据实际问题分析是否需要对特征进行相应的函数转换。
9 B$ e" Z+ }: K 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
: j {3 l& ]- Q( q) A 因此针对动态的数据可以采用如下几种计算方法: * t' n0 o# f, f3 Q: n% F
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 : F; [0 W* Q, ]5 J% }+ R$ C, ?8 w
) m. Y% b: k, M7 H
1 I W' |0 I2 M+ N$ a, x
* S' ^: B7 F! v2 m
5 [: w- U9 a( o& P& k9 c+ w
| 
