|
* u1 P1 h$ f n+ w
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 8 ?5 y9 c+ n# g( i; P& i3 @4 I ?
归一化是标准化的一种方式,
' y! j: U* p6 _# P 归一化是将数据映射到[0,1]这个区间中, & ~3 x# @+ t9 g
标准化是将数据按照比例缩放,使之放到一个特定区间中, & ~4 d9 W! `2 U
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. ) z `8 |* ~/ d) j% w% w; B
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
M$ `8 S: C* A. d7 x 导入模块:
2 q* J1 `& S0 K' g8 I. q, `/ Q from sklearn.preprocessing import StandardScaler" u3 z# S* v4 T3 o% o l* O
from sklearn.preprocessing import MinMaxScaler& h E4 J5 ~' _& p! W0 B
from matplotlib improt gridspec
n' {. Q) c, d, `4 R# | import numpy as np
8 e( f0 y8 n" z# ?/ M/ Y import matpotlib.pyplot as plt
7 R3 ?9 F# D5 X% \! A; D+ Q/ g" c 使用sklearn 进行标准化和标准化还原/ i' N7 t+ E2 y z Y
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x) - }* \ Z1 Q9 i$ E
std = StandardScaler()
/ J6 Q1 D/ r: |# Z data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]): z. U- M7 Y) c& I* v; d& Z
( [- P$ l) b7 y) R. A4 q. t/ }0 S # 将标准化后的数据转换为原始数据。
. P; p: r. a# |/ |4 @* ^ std.inverse_transform() 4 I" K' O, U" c; @
查看标准化后的数据的均值与方差 . Z( S, b- f- T: k
x_scale.mean(axis=0)# 均值
1 H: U6 @4 v2 ?0 b, j # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
% l+ w B0 Y, b6 N x_scale.mean(axis=1)
! f' a; m& F7 y- E! J ` ' j) V5 F0 S: e8 Z$ \& k' R1 C# F
cps = np.random.random_integers(0, 100, (100, 2))' W4 O }2 }. @8 Y' t# l' c# G
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.+ ^( L- l! `# S
ss = StandardScaler()
8 M4 v* V0 }) r& E* {7 [ std_cps = ss.fit_transform(cps)
4 x( ? Z J/ s8 c gs = gridspec.GridSpec(5,5)
* ?5 S% s% W3 P; F fig = plt.figure()
S% T# j* ^" n: P+ e ax1 = fig.add_subplot(gs[0:2, 1:4])! C1 |4 a& H# u \
ax2 = fig.add_subplot(gs[3:5, 1:4])
/ A6 |7 j6 Y$ D/ L8 x5 q' ] ax1.scatter(cps[:, 0], cps[:, 1]). I# }! {- f( H: T( l6 M
ax2.scatter(std_cps[:, 0], std_cps[:, 1])8 V/ v; L) `4 x2 r( i* y' B; d0 J
plt.show() * F1 { p# n4 Y. l$ a" m# ?' G
` . m ~2 ^( R* r% n
from sklearn.preprocessing import StandardScaler
7 D4 o6 P3 q [+ K7 h from sklearn.preprocessing import MinMaxScaler0 k( w$ e8 S, T, ~
from matplotlib import gridspec
# P' f8 f0 [0 I; b/ b; H import numpy as np* x+ c& M2 I9 G/ \" s
import matplotlib.pyplot as plt
$ T6 |5 [& {3 t- t/ i6 }) v+ B data = np.random.uniform(0, 100, 10)[:, np.newaxis]
j: M1 I7 p. G: T ss = StandardScaler()
/ C3 [" P; q1 ?! b std_data = ss.fit_transform(data)
" C" x" o" w* k, C: p, ? origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据2 @: w7 g2 V1 ~2 p- g) `4 C/ [' ]
print(data is 原始数据,data) J6 N7 r7 x$ }! r2 E
print(after standard 标准化后的数据,std_data). C' u2 H: K1 e$ m% \3 O: ^
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)1 @1 e2 Z, t* [* O- Z d$ }
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
8 \% N" k% {9 g6 ~9 ?. O* Y7 [ 使用sklearn 进行数据的归一化和归一化还原.+ |' ]$ i5 H \( D1 D8 i6 Z
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据# Z: ^( C" Y8 g4 q! S2 R8 b
mm = MinMaxScaler()# 创建MinMaxScaler 对象& g) C2 n& I) U) R7 x: u! K
mm_data = mm.fit_transform(data) # 归一化数据
- d5 g5 r. O$ p6 U \ origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据/ k) S( e1 O X0 A8 X, O
print(data is ,data) A; z: `* B1 ^5 g5 {
print(after Min Max ,mm_data)
3 Y3 U2 R$ y. {$ V5 e4 z& x print(origin data is ,origin_data) ; O4 ?. V5 R7 q7 z
MinMaxScaler和MaxAbsCaler:
, U: h( Q; H- A8 q: [ MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) $ }- A( c2 g3 [5 W* }5 u; L
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
8 ^$ t. y$ q6 H+ H8 I6 S min_max_scaler = preprocessing.MinMaxScaler(): z( L6 f4 |4 w7 H
x_minmax = min_max_scaler.fit_transform(x)
; s* F! t5 w4 g# l" O* ] x_minmax
" v! G e8 U% K/ ~1 E( x' Q5 @* Z 对于新进来的数据,采用如下方式进行函数调用:
/ X' x: {0 K! r$ o# E- L x_test = np.array([[-3., -1., 4.]])
3 e/ w' U' G) Q" B; k x_test_minmax = min_max_scaler.transform(x_test)
5 w! I0 D6 r# } x_test_minmax 7 {# _- `$ {* y; e. ]& a# i+ ~5 n; y
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
9 R$ s% N4 u5 d" L! S C max_abs_scaler = preprocessing.MaxAbsScaler()
$ Q3 V4 y$ e e6 x x_train_maxsbs = max_abs_scaler.fit_transform(x)4 o. d- M+ t @- M
x_train_maxsbs
% f: g, k0 }/ B( K- l1 W, G- F # 同理，也可以对新的数据集进行同样的转换
+ N4 Q v, N/ S x_test = np.array([[-3., -1., 4.]])4 G- p2 o0 h, X/ j
x_test_maxabs = max_abs_scaler.transform(x_test)* Z6 A% a, R1 i& \9 Y1 D1 J
x_test_maxabs 1 ]& i6 y2 R b) ?2 Y! a
针对规模化稀疏数据3 e3 c: M0 g! K3 U X/ O
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
) P8 j$ n5 U5 B% f& j5 n& E j MaxAbsScaler,和maxabs_scale
% ^3 m% S7 z+ o, Z4 O8 X 针对规模化有异常的数据; M7 m5 k: o9 F& e7 V
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
/ K( G; x0 n' t* u* q6 D' n- ~ 正则化Normalization
" x* g! E0 Z# D# c7 X3 L 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 + P6 n+ d6 }, m( @
x_normalized = preprocessing.normalize(x, norm=l2)
" s& l" b# s. `6 J' g/ E U9 e print x0 P5 C8 N& T8 {* J) Z' t
print x_normalized
0 o7 }! z% M8 o! Y8 u$ t0 L # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
5 c1 U; W* B. X2 h normalizer = preprocessing.Normalizer().fit(x)
& ?, D D5 b7 Q# w normalizer
& P4 r, v8 H4 h6 @ # 对训练数据进行正则
6 c9 x- N* y% \3 K9 `$ V normalizer.transform(x)
) V: `& r% W, v! m( g9 H& {+ P, i # 对新的测试数据进行正则 ' Z; ?: a4 Q' h1 m
normalizer.transform([[-1., 1., 0.]])
! S) B& t) |' e# z* i& T) J 二值化2 u2 Y) H' N V" [# n; s
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
}# ] ?, L$ | g from sklearn import preprocessing
4 @+ y4 e. e, x/ q3 k6 @ M, K import numpy as np: e& A7 J( T0 n7 L/ [
! [) S O. l: W) Q4 i& } P8 o! ^- z # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征1 @4 `; S! \" [4 h. l9 R
x = np.array([[1., -1., 2.],( c# Y$ U' |9 h5 u0 q% z
[2., 0., 0.],3 h, H( ?( [* x1 t* t2 h: x6 {
[0., 1., -1.]])8 |, r" ^4 n. l
& K1 N) a6 F H7 b
binarizer = preprocessing.Binarizer().fit(x)+ S6 O7 f* i }) V4 O4 b
binarizer.transform(x)+ p! E3 g$ w8 u
& w7 v$ Q3 O- _/ l" c# y; P binarizer = preprocessing.Binarizer(threshold=1.5)
8 P4 A2 \+ P& G( ?7 n* p2 E2 Z& l binarizer.transform(x)
p& u: n2 q* K; Y, T0 B2 i* A 为类别特征编码
2 E, P) S6 n* j: F (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. , p: L7 n ?4 ~& L) T0 x7 x+ O7 n
OneHotEncoder
7 b" u8 K6 p0 l/ n; U; D 弥补缺失数据
8 W! Y2 s: j! v. I0 W 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 9 Q. l3 r4 n* x" x
import numpy as np
' |* t+ \* G- T1 Z/ C5 o' | from sklearn.preprocessing import Imputer
) x4 D5 I* U5 r3 r; a$ p imp = Imputer(missing_values=NaN, strategy=mean, axis=0), o) Y1 k. b. k7 F& N
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
" v% p1 _, H8 R8 [5 x; R! P x = [[np.nan, 2], [6, np.nan], [7, 6]]
6 r5 X- ~ l' B- \1 D: [; g imp.transform(x) . R2 ]& N3 G" @" b
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
* i1 W8 z5 N& }4 o( `7 x8 Z import scipy.sparse as sp
; X$ q; a* q* ?+ y3 i8 K9 R/ v # 创建一个稀疏矩阵0 d+ Z9 z \5 @6 R7 U! n9 g) r
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])9 N& r) l: Y6 f( U" |& C
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
! F) H9 M1 d7 y6 A8 g. A imp.fit domain name is for sale. Inquire now.(x)
j# Q) \" E' r# O0 S x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
5 B1 d1 I: R5 U! L# l9 K \ imp.transform(x_test)
/ `% V/ b* {7 ` 当我们拿到一批原始的数据 $ i4 K- E' e2 C( K3 B1 z
首先要明确有多少特征，哪些是连续的，哪些是类别的。 $ [' r, L' x3 X' D
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
- M6 O! y" a. M7 k/ _! L! j 对连续的数值型特征进行标准化，使得均值为0，方差为1。
: x$ h B" I# B. U% f 对类别型的特征进行one-hot编码。 # i. n/ p l) ~
将需要转换成类别型数据的连续型数据进行二值化。 " ]6 i; v& l( c
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 # F( `+ j- A4 {1 J- a
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
/ J1 U9 B# b' a9 n5 |8 J* S 根据实际问题分析是否需要对特征进行相应的函数转换。 2 a6 K/ c/ o# U. r) A# `9 r
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
9 ]" Y1 d% l, a, M 因此针对动态的数据可以采用如下几种计算方法:
; R: I$ r% j+ Q0 I, @# @$ i 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 5 Y8 }7 i' u3 W0 h% B# t8 s4 P
3 x Y' ?* H+ G$ I, j0 u2 R$ W
Z) H7 ~* ?7 t/ Y6 y, R; Z
5 T$ L. ]9 H* M3 U
0 {, X0 Z7 k- {" {# R1 f |
