|
! R4 q1 Q; \+ P7 `2 K' J sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 3 L* P8 v4 i3 f8 [" h
归一化是标准化的一种方式, # z+ b! I: F4 t5 T% I: c& V: l
归一化是将数据映射到[0,1]这个区间中,
( o+ [, ^3 E4 P# G 标准化是将数据按照比例缩放,使之放到一个特定区间中,
6 F" k0 _0 z1 v+ V( M6 s) Q) z 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
5 g2 ~+ P% i% A; F' N 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
. N; S/ D L! B7 \& m 导入模块:
$ o" w$ L& E# v9 K, |' _7 F) `: U9 @ from sklearn.preprocessing import StandardScaler! }; E( Z9 G' ^- H
from sklearn.preprocessing import MinMaxScaler- p7 V9 T' H7 h% P. m- j
from matplotlib improt gridspec( Y$ G! @; H/ K M& K
import numpy as np8 q. U+ \4 m5 y# q/ J! N5 Z
import matpotlib.pyplot as plt
4 E* _1 R/ ?5 `/ W w) W- l 使用sklearn 进行标准化和标准化还原9 {. b( E. i7 L- i3 P
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x) * O2 ^0 O, i6 T( _; [ d6 S
std = StandardScaler()
1 B/ N8 l( ~' m& F$ c data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]), m b3 g) Y9 |' c7 E- Y: V! _' C
8 l+ h, H( {9 p( g: y # 将标准化后的数据转换为原始数据。
5 U# \6 \0 _: j/ y7 W3 M/ x6 e& N std.inverse_transform() ; A) g: c0 v# Y% \9 A
查看标准化后的数据的均值与方差
. |: ]$ i& C8 h x_scale.mean(axis=0)# 均值
( {% _8 {& p! Q9 Z) F& W # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
8 q. Y* q3 z6 z" S, h' u }9 |1 S x_scale.mean(axis=1)
3 @0 G# X' n$ a ` ! n3 G0 v& ]8 T( _0 x
cps = np.random.random_integers(0, 100, (100, 2))% x) C6 E8 @6 ~( X' _
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.5 B/ k e9 ?8 N: J9 _: M
ss = StandardScaler()8 c( f2 [3 o) D, A( ^7 s
std_cps = ss.fit_transform(cps)- d4 D' u6 X% l8 j
gs = gridspec.GridSpec(5,5)
5 O2 `0 {& B0 K fig = plt.figure()6 u1 z1 i" w8 i. M% V4 o5 J! z
ax1 = fig.add_subplot(gs[0:2, 1:4])* u7 q: b: z2 U$ h3 W
ax2 = fig.add_subplot(gs[3:5, 1:4])# X4 l) x& U$ f* M6 _7 x: m5 h7 Z1 F* c
ax1.scatter(cps[:, 0], cps[:, 1])1 W" }$ B" ]' A9 J( c5 [* ]
ax2.scatter(std_cps[:, 0], std_cps[:, 1])2 j7 f+ L) b" s$ G6 V
plt.show()
5 q i! f: R& i( d7 q1 T `
$ Q% k3 [/ r: g9 k6 b( B5 Z1 |8 w from sklearn.preprocessing import StandardScaler x8 X/ Z& x7 D4 _% B# {2 ~- O
from sklearn.preprocessing import MinMaxScaler# E/ V8 q2 a6 g9 t# e$ U
from matplotlib import gridspec# X4 p; P3 Z) \- p
import numpy as np- V R/ n1 `' S7 D# |( {
import matplotlib.pyplot as plt: H: s) [" i: i# W3 Q6 \
data = np.random.uniform(0, 100, 10)[:, np.newaxis]# R& Z$ i t" K) y
ss = StandardScaler()$ w! K7 r1 l$ Z5 F- m5 j7 j# Y; ~; p
std_data = ss.fit_transform(data)# u" a) ?( S- o# J$ w. \% q
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
4 V6 v1 V4 A: N& j: ^$ H6 U; c print(data is 原始数据,data)
+ J' ^' a- q I% B# R9 O" P6 S$ X) ] print(after standard 标准化后的数据,std_data)) F' K% C- s1 }/ ^4 S. j
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)% P1 u" e$ \* ]/ r* J4 g$ S
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) ( V% |& @2 M3 U% K* x8 I
使用sklearn 进行数据的归一化和归一化还原.
* ~6 g# e) z6 M. u data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
* t, o. r+ @- |$ x mm = MinMaxScaler()# 创建MinMaxScaler 对象
9 g9 t$ c4 ?* x9 a: C mm_data = mm.fit_transform(data) # 归一化数据
5 ~1 s& V: B9 b7 ]: y3 K) C/ J7 y: z origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据! f0 j2 R" l4 B2 m
print(data is ,data). p$ ]3 s% Z5 j; c% H" q# c/ M
print(after Min Max ,mm_data)
9 i3 P" s6 e5 F print(origin data is ,origin_data) % A9 |+ N2 O0 x: a) J9 A& Y6 {! N, u! B
MinMaxScaler和MaxAbsCaler:* W) d8 D3 T4 J* L$ {
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) - _( a! Y2 x" I' M: E5 a! p
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
. ~7 |' E1 ^1 `/ f! s4 E0 u, O* n min_max_scaler = preprocessing.MinMaxScaler()
$ }0 Z7 Y5 q9 [5 s2 k x_minmax = min_max_scaler.fit_transform(x). M' k+ e9 U7 ^0 e u# J3 C
x_minmax : S5 r# f5 a3 ~1 W1 E
对于新进来的数据,采用如下方式进行函数调用:
# F, r* [8 s" H" h6 p5 \' m- F# k x_test = np.array([[-3., -1., 4.]])
8 b' j- {, J5 d& ~% q x_test_minmax = min_max_scaler.transform(x_test)
" ]" |% q9 q- ] x_test_minmax
! J+ N* P, r/ H. R) U MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
: a0 C- F- e( @+ d8 Z max_abs_scaler = preprocessing.MaxAbsScaler()
2 A7 K# E1 N& D x_train_maxsbs = max_abs_scaler.fit_transform(x)9 E, h4 Y; M" h: Y6 ]& \9 P
x_train_maxsbs . f. i) `& f% x% m6 u, g8 g8 S
# 同理，也可以对新的数据集进行同样的转换 Q8 H+ K8 A$ l9 _) t O) p, Z
x_test = np.array([[-3., -1., 4.]])9 t4 R i$ Y% _7 {
x_test_maxabs = max_abs_scaler.transform(x_test)
9 q" d. a" O5 d# T6 z x_test_maxabs
7 |& J3 [+ Y C- g! [ 针对规模化稀疏数据+ f8 u9 o/ l% w! @! u* V( s
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
, e) ?; J$ _- W0 s b- s# L, ^1 h MaxAbsScaler,和maxabs_scale , S3 n% ^& A0 }# b, A6 `- L4 q1 ?
针对规模化有异常的数据
' ]3 a0 ]( C' n% a, y. ?8 s( J 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. , v! f! t' a0 @8 y9 Q O
正则化Normalization! j3 B; ~5 B: Q0 m* q4 L
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 \" k& f- a+ ~; k1 n l* J! w
x_normalized = preprocessing.normalize(x, norm=l2)# u0 u0 N2 R7 T
print x9 ]8 v/ Z. Z' z9 G
print x_normalized
( o) D0 h# C! o6 N/ j # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
' X3 F/ _) H- U6 Z# i( v normalizer = preprocessing.Normalizer().fit(x)9 {0 `% ~# F) I+ P' i& i" R
normalizer ! o4 E/ o4 u3 e0 K9 ]" ?
# 对训练数据进行正则 ; K$ w9 G% \2 L0 H, y
normalizer.transform(x) . k: m. Y6 y/ A) U. W& o& a* |
# 对新的测试数据进行正则
& r3 D# {: y! V d. T4 h normalizer.transform([[-1., 1., 0.]])
: v$ Q* E: a% a0 b5 ? 二值化# ]/ P* n; J$ n: ~1 ?
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 & A0 d( y* {# R/ t
from sklearn import preprocessing/ W8 V8 X; M7 P/ {1 a
import numpy as np1 I3 _, E0 c, |4 D9 \5 N( p) p/ B
; T$ `" N' E7 G: W # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征' `* [% J d! s4 Z" R
x = np.array([[1., -1., 2.],
$ `! l6 u# N' | z' D [2., 0., 0.],
2 {& F$ I3 b; y" D4 H. F [0., 1., -1.]])1 r6 ^/ S" l+ d. t
& `1 \! f4 _ @/ o binarizer = preprocessing.Binarizer().fit(x)
" l& J0 E0 c. i, t% R binarizer.transform(x) q2 P# _2 D' ^- o# _: u; S# a# N
, b' Z. M! L5 N5 w4 x# G
binarizer = preprocessing.Binarizer(threshold=1.5)
4 G+ V; ?/ V2 o! y binarizer.transform(x) ) R" P/ ^1 l1 O6 K9 ^
为类别特征编码
3 z. ~) e+ T) G H (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. 7 k# {% o* |4 w1 H
OneHotEncoder
2 Z5 H3 ~& Q" [0 p+ W 弥补缺失数据
8 s' u; j3 {' d1 a6 K8 m/ P$ R) ] 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
* e- X' D2 d6 ]2 a- b import numpy as np
0 O. Z* H1 g7 ^$ j1 W from sklearn.preprocessing import Imputer) F$ X& P* z$ @/ s; O
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
* M1 E7 I/ t# \5 [/ p$ G& t) | imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])& x/ `0 R3 k& d4 H) p X
x = [[np.nan, 2], [6, np.nan], [7, 6]]
' f+ v; Z' t G" A imp.transform(x) ! @- H6 k; U, s2 J# Y4 N( }5 b
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
: R4 E2 A" p2 Z7 c) q# q7 I import scipy.sparse as sp
1 e* X* i6 @. |0 t& O4 @7 e # 创建一个稀疏矩阵
; x9 [& ?+ }* k7 f% D; b4 X; K- u x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
9 }7 N7 V7 Y9 i9 l1 [' p imp = Imputer(missing_values=0, strategy=mean, verbose=0)
- k0 c& y1 j6 J0 [: R3 A! ^, @ imp.fit domain name is for sale. Inquire now.(x)& M. ~ y3 ?4 X% g" n. Z8 r
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]) Z2 q/ j7 H1 j8 e) ?7 f
imp.transform(x_test) , [' G, X- X l; b {$ L
当我们拿到一批原始的数据 + {# r: N: v1 M/ f+ r
首先要明确有多少特征，哪些是连续的，哪些是类别的。 1 S% k6 G) S5 e
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
& S' k. D; y; o 对连续的数值型特征进行标准化，使得均值为0，方差为1。
8 n- ]- s- c- P% {: s2 A3 S( j" n: Q 对类别型的特征进行one-hot编码。
~2 w0 i% P. t8 }* }7 j 将需要转换成类别型数据的连续型数据进行二值化。 ! P/ ~+ s, j& I; N
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 + h% P9 U n0 L7 r9 \0 e7 _+ F
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
4 X- V0 d z- @3 N% C5 k& c { 根据实际问题分析是否需要对特征进行相应的函数转换。
8 t+ }8 r0 j6 w/ I# s! h2 T 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
/ b* [2 s5 R3 y$ Q 因此针对动态的数据可以采用如下几种计算方法:
3 ~! p& j; A8 B" ~8 F7 \5 p( t4 d6 O 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 ; d7 T8 \* ~8 f2 b. M
6 s6 d; Q0 }4 A2 b: x8 A
$ e9 E" }9 A* p5 A! m/ U4 j" u& {
1 T' ?/ k& s9 Q' E6 A- ~3 C: A
* [, m, l' L1 l2 \' }7 i5 j8 ~' B8 v( [1 q | 
