|
( p$ ~/ T4 K" ?5 B, \ sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
* W4 y0 Q9 v+ E) C% U+ w 归一化是标准化的一种方式,
/ d% H. V/ Z6 v1 K5 _1 w 归一化是将数据映射到[0,1]这个区间中, # G' x7 G' Y" c ~5 U5 X( V+ _. D
标准化是将数据按照比例缩放,使之放到一个特定区间中,
& e% Z* ?' v( `4 h6 p7 s7 I( o6 c 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
7 [; V( s- i% }' `( F 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) 1 {# s' ]; ?0 W( `- s) W
导入模块:
3 O: T6 L5 F& v! ^8 s& x5 ] from sklearn.preprocessing import StandardScaler
& O5 f- y" o6 N$ ?9 K from sklearn.preprocessing import MinMaxScaler
- Y/ L1 n1 A2 ~# L from matplotlib improt gridspec( l l/ S0 A; A* W& j
import numpy as np. Z: `" h, B2 X7 k
import matpotlib.pyplot as plt " g) Z. P; |" y- F
使用sklearn 进行标准化和标准化还原
3 y, E7 p3 S4 F/ H2 _- c) r 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
2 k# `7 p6 g) j" i' W8 I std = StandardScaler(), q5 a0 m* D4 z; @, i1 d
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])2 ? \4 q$ B I& s h
, X2 Q# Y& r2 U- V/ G # 将标准化后的数据转换为原始数据。
7 W% L0 G7 P9 r: T) A std.inverse_transform()
2 Z! C% M/ a. ^. y* ~- r 查看标准化后的数据的均值与方差
+ R2 G. w8 p6 h, N+ h! Z x_scale.mean(axis=0)# 均值 3 T8 g; P1 n9 G& I0 @
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 + K1 J; p* ^$ @+ M, S4 H% ^
x_scale.mean(axis=1)
. W4 O3 o8 C# n: }9 X ` ) x+ D" B, r, ~/ A% q' `. m
cps = np.random.random_integers(0, 100, (100, 2))' A, h% ^7 G( r0 p! H
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
! t' q3 J- ?! Y1 ~ ss = StandardScaler()$ I3 }+ e4 B% A! _6 X1 q- `- ~
std_cps = ss.fit_transform(cps)
- {* C4 p: u+ q gs = gridspec.GridSpec(5,5)& O$ u* b/ C8 s; }+ i2 R. T' t
fig = plt.figure()
2 N: q# z4 L1 E ax1 = fig.add_subplot(gs[0:2, 1:4])
. u. i( i" Q5 N6 G9 n ax2 = fig.add_subplot(gs[3:5, 1:4]); p0 O+ b3 D0 b
ax1.scatter(cps[:, 0], cps[:, 1])& q2 L- P' n/ W4 @
ax2.scatter(std_cps[:, 0], std_cps[:, 1])! Q. P* q5 r- }. f$ k) z8 p: c$ t
plt.show() 6 W3 b6 l; W+ t& G* f
` 7 b1 ]4 v! Q1 P: `$ n
from sklearn.preprocessing import StandardScaler2 F* w8 \1 @9 Y+ k! a
from sklearn.preprocessing import MinMaxScaler
& ^9 ^, s/ D+ S0 X( z2 Q# ]! Y W from matplotlib import gridspec
, O: N1 ^* Y3 s+ | import numpy as np2 \4 r2 q1 F4 F* X" z% `! Q
import matplotlib.pyplot as plt
6 d8 \$ B$ H: `, L a- b7 b0 Q data = np.random.uniform(0, 100, 10)[:, np.newaxis]# _# z& l2 f) n( M, W4 c: Q8 u" w7 Q
ss = StandardScaler()4 c4 |& {; `; w7 y7 Y* f- ]
std_data = ss.fit_transform(data)
7 o- X0 F! @( d0 q# a( n+ I9 F3 G origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据2 M/ y! w4 P D
print(data is 原始数据,data)
2 o4 r5 H3 J% b9 v2 h7 E; L) z print(after standard 标准化后的数据,std_data)
4 q- M" f- J0 {& E' ` print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
8 m' Q, c1 L6 B( x print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
( ?! a( J5 p2 {. K7 R, J 使用sklearn 进行数据的归一化和归一化还原.+ k8 K0 l8 i! [- N1 |
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据8 b6 O7 U% X* _' X
mm = MinMaxScaler()# 创建MinMaxScaler 对象
% \! o( f1 e# r( r: r mm_data = mm.fit_transform(data) # 归一化数据! Q: C8 l }/ z9 J0 G
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据6 O9 o2 P2 g; n1 L6 I
print(data is ,data)" S& M. S( z1 C1 A' O
print(after Min Max ,mm_data)' N5 ~! G" Y& g* y
print(origin data is ,origin_data) 8 L0 Y7 D2 Q5 P2 V' T3 ?
MinMaxScaler和MaxAbsCaler:
5 |% k. W" f" ]) f; X MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
. A/ n2 @% n4 }. T9 y MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
8 w- Z6 P8 r) ] min_max_scaler = preprocessing.MinMaxScaler()
2 ~4 ^) R" m" v; {) K% q x_minmax = min_max_scaler.fit_transform(x)
4 a+ N9 @" d z* \$ B x_minmax + y1 k" y/ H. w1 S- g" r
对于新进来的数据,采用如下方式进行函数调用: ! _ E& L/ U* K s$ n! p# ?, P
x_test = np.array([[-3., -1., 4.]])
- }$ a9 p: z0 F* U( ]$ i7 A x_test_minmax = min_max_scaler.transform(x_test); v: K4 _6 p4 l0 p" Y. H
x_test_minmax
0 x) S$ A' |5 h MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. . h4 @2 z) t" D3 x* z
max_abs_scaler = preprocessing.MaxAbsScaler()
- C. x4 G) ]( y7 N8 z x_train_maxsbs = max_abs_scaler.fit_transform(x)
& z$ z. Y7 j/ w9 o W6 ?! }! D x_train_maxsbs
9 `5 X! X5 N0 I$ M2 E2 x8 | ? # 同理，也可以对新的数据集进行同样的转换 . }! }: B/ O9 I0 z" R
x_test = np.array([[-3., -1., 4.]])
, O8 z' j: a) m, r x_test_maxabs = max_abs_scaler.transform(x_test)
9 S# ^! G6 \$ P: f q x_test_maxabs
3 h+ U m: }1 I' X& @4 E 针对规模化稀疏数据
9 o9 u$ g- ]0 j- |" [) ` 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
5 C: ?0 k/ x6 L# B, V4 N MaxAbsScaler,和maxabs_scale * F4 _: A3 Q" d
针对规模化有异常的数据
7 s1 a/ Q" \. i9 x8 B+ [3 D, o 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. % G6 S8 O7 b C& M* i* w
正则化Normalization, E1 y$ p5 L' c& ~ L
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
% [4 j8 l! T: C& c5 r- Q x_normalized = preprocessing.normalize(x, norm=l2)4 C' b% h% U" w
print x& b$ W$ N& |5 w* g$ v, z
print x_normalized r2 c; v! D$ ~
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
7 G8 O8 M% A- F; C7 r normalizer = preprocessing.Normalizer().fit(x), k: X: u6 c5 S ~' C+ q4 w
normalizer 4 ]! t: b5 J5 U2 y; g7 l
# 对训练数据进行正则 V, ~! g c1 m4 B' l* {8 w
normalizer.transform(x)
2 F+ Y( O9 h) j& e& L/ H+ f: [ # 对新的测试数据进行正则 1 D3 u$ l+ Y8 k# M$ q, z7 }9 O( h/ C' U
normalizer.transform([[-1., 1., 0.]])
, {7 C6 F: ^' G1 A6 G) l 二值化
: Q$ H$ F# z+ g; d* r, K0 }" G* e6 v 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
+ u7 { [$ c1 o+ L: p' B7 W from sklearn import preprocessing
, h: I( |- X, @- H; t: i# ` import numpy as np
6 J. p+ M9 D9 x3 h0 M% S$ C( r* f1 M# f; V/ ]+ S# \0 c. ^' d
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
+ @/ e9 _4 `# G% T5 y0 b x = np.array([[1., -1., 2.],6 l3 ~" X$ N; }4 |- f. l
[2., 0., 0.],
; [1 i2 L8 w" d! h [0., 1., -1.]])# g2 T: l' L: }; H0 z, }
9 i$ k. j- L1 D+ A; N. H8 N* o' S" n
binarizer = preprocessing.Binarizer().fit(x)# e I. b( |2 W2 N5 ?+ o5 A! i. V
binarizer.transform(x)
" r6 D) G) S3 B9 [' T! H5 U0 b; E: O8 y4 i' ]/ G
binarizer = preprocessing.Binarizer(threshold=1.5): |6 X- x! U+ _/ Y3 Z& l' u
binarizer.transform(x) 1 y5 C# C5 |$ \! ?+ ~ y
为类别特征编码; \. _1 F A6 a3 ?! O4 n" n
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
2 D' R4 _4 f4 X" Z) z" q; f% l OneHotEncoder
8 I0 X. K q9 q 弥补缺失数据
* N, s# Z. H& i# I8 ] 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
! ^1 L: P! U- Q. E' h- y+ o0 R import numpy as np! w# h/ U4 t# |" P2 V$ U2 D
from sklearn.preprocessing import Imputer7 j$ D& ?/ |% P/ W8 X, j$ R+ y
imp = Imputer(missing_values=NaN, strategy=mean, axis=0), U5 t* }: t, M
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
; i) ]9 o# |& g2 t x = [[np.nan, 2], [6, np.nan], [7, 6]]
& L/ t6 P4 d; j% d imp.transform(x)
) F q4 v# g! G6 i Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
5 K& k" x1 o) c/ b import scipy.sparse as sp
1 R6 s/ s2 S1 J/ z B7 X) G # 创建一个稀疏矩阵+ i. f& ~' z" N
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
9 h' x2 i8 ]- E imp = Imputer(missing_values=0, strategy=mean, verbose=0)& d: w# k+ A8 J2 w3 ^: S
imp.fit domain name is for sale. Inquire now.(x)9 S# }& J s$ v& s/ |2 x
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])( }, j: \; k7 T: ^* Y7 M) m
imp.transform(x_test) ( e; O. q, Z+ g
当我们拿到一批原始的数据 : x: Q M3 _2 A
首先要明确有多少特征，哪些是连续的，哪些是类别的。 ( b; u% e5 x' [6 B& K5 `; r
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 9 \! J! R$ r- c' X9 S9 y
对连续的数值型特征进行标准化，使得均值为0，方差为1。 $ b4 z$ W2 m, A; f3 X2 a0 t& G9 A
对类别型的特征进行one-hot编码。
- H8 U5 B7 C4 u" F0 `8 v7 Y( {& \ 将需要转换成类别型数据的连续型数据进行二值化。
; v) a& {$ n9 C4 z 为防止过拟合或者其他原因，选择是否要将数据进行正则化。
9 D/ f7 O* ?: V c: |; m3 U 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
+ ~* W: i: F. m/ s. l 根据实际问题分析是否需要对特征进行相应的函数转换。 4 N& H6 R+ J- r" S# A- e& w& X# T% u
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
" I# Y/ N% q" H Q 因此针对动态的数据可以采用如下几种计算方法: 6 U6 k& ~+ h. b) K8 u
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 , k1 M7 p0 o! M$ r. x% F4 q
) o% m6 N# N$ F1 ^ g; D7 J9 T& p
6 Y$ n, ^- [* r" C0 E V( G! @6 _1 q# r$ o- _! p9 W
, Z* |, r; b8 @: L$ t. c7 F8 Y |
