|
% B" E4 z) p8 R, p' A2 B, t5 b$ E
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: # F u+ W+ ]% {% {2 h, X: ^
归一化是标准化的一种方式, & t9 d% e% k6 D E( @; a4 [
归一化是将数据映射到[0,1]这个区间中,
5 n" Q9 a" g8 Z" `8 M2 z+ j' s 标准化是将数据按照比例缩放,使之放到一个特定区间中,
; H! L8 H3 J5 Z. p, S9 L 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
4 r& W. D. }; n 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) 7 h( o3 S2 ?" R+ X4 ^6 s7 P6 _& g; B
导入模块:
$ ]# |, U$ w" ?# X from sklearn.preprocessing import StandardScaler
1 v6 N: t4 q/ i) u from sklearn.preprocessing import MinMaxScaler- H! u' e% j$ b' X) l
from matplotlib improt gridspec
R" c7 f1 k0 i, c6 B import numpy as np( @2 ]3 i3 G4 g# }3 B
import matpotlib.pyplot as plt
% l4 p0 m" j1 @ E( o4 B! w7 D0 z ^ 使用sklearn 进行标准化和标准化还原2 C9 b& V: V' \( {& z0 U0 s3 i$ w$ ^, K
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
" I1 v* r" S: k: U5 O- ] std = StandardScaler()
; c" X/ S1 a5 L8 F# y( ? data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])( Q# } ^0 c9 _& R+ r/ M
0 B, [4 G: {, Z1 R
# 将标准化后的数据转换为原始数据。
6 Q9 V B0 h; O# d& ~9 I7 u std.inverse_transform()
0 s0 a/ s& u9 O+ O3 T! B1 } 查看标准化后的数据的均值与方差
3 j. O% A0 T7 k) } x_scale.mean(axis=0)# 均值 ! y5 Y( i: U; ^0 _6 f
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
5 L6 h) `9 }) J. R2 l% p! X x_scale.mean(axis=1)
3 o+ J w6 M% f; a$ V ` 2 v2 r1 z1 P% ^
cps = np.random.random_integers(0, 100, (100, 2))
5 E7 {4 }. d# c% Z2 _ # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
* b( F0 X N( P ss = StandardScaler()2 U# @/ ?7 I2 a
std_cps = ss.fit_transform(cps); `1 Z3 f0 H2 g8 |- [% ^
gs = gridspec.GridSpec(5,5)
" U1 x8 f% v* F! A fig = plt.figure()
1 z, H1 b L2 {% c ax1 = fig.add_subplot(gs[0:2, 1:4])
: t+ i6 v7 d! B9 L V5 I+ d! R ax2 = fig.add_subplot(gs[3:5, 1:4])
$ k Q5 E* g- |( v- P- o; s0 q, Z ax1.scatter(cps[:, 0], cps[:, 1])
- h% H1 R/ ~- w* W6 ^9 ` ax2.scatter(std_cps[:, 0], std_cps[:, 1])# o5 P s4 x0 N
plt.show()
" P8 g& P8 |8 r5 ?/ D `
7 Y3 S9 B3 b" @6 p$ T: i from sklearn.preprocessing import StandardScaler
1 i9 Q* e1 A- @6 \ from sklearn.preprocessing import MinMaxScaler
* X* A6 k, u2 Q3 A1 P from matplotlib import gridspec' h0 I! t: [- ^. [) z) |
import numpy as np/ }5 M( V: h* z
import matplotlib.pyplot as plt& c- i5 s! a# u" Z
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
/ p' C& S0 f4 k; Z ss = StandardScaler()
- h- T; ?3 \% K% v$ v( L std_data = ss.fit_transform(data)
% T* g) q( N# S( K8 Y. r origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据4 K; i1 Y& P8 j- @4 o; f! E4 o
print(data is 原始数据,data)# r- W1 Q( e0 `/ H$ T [
print(after standard 标准化后的数据,std_data)
# s+ M) B$ w# m) y+ i, }8 G7 ?1 S print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)7 \5 @( z( X7 f1 W( ? Z; f
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
7 S. H7 ^- {7 ^# c 使用sklearn 进行数据的归一化和归一化还原.1 r8 }# h0 G) J% A
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
2 Q) C' O5 A) V mm = MinMaxScaler()# 创建MinMaxScaler 对象
0 B$ |; b0 T) v+ b mm_data = mm.fit_transform(data) # 归一化数据
' i0 t0 o( ^" q% N origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
; K8 T5 ~1 h* x7 n2 \ print(data is ,data)
! J; ~/ E6 v7 W& N' p print(after Min Max ,mm_data), c F. u# v7 Z& o8 V
print(origin data is ,origin_data) * w* B. \# i, G& M9 Y) D; ^. a1 Z* f
MinMaxScaler和MaxAbsCaler:
: p9 M' A/ i: k4 R; i1 |$ e6 z MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
- ] x" z+ {. t+ } MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 9 S+ V; `- \- D% ?
min_max_scaler = preprocessing.MinMaxScaler()
7 G1 r( J) K5 s s) [ x_minmax = min_max_scaler.fit_transform(x)4 u/ k+ Y0 \) [, i
x_minmax 4 F1 b/ m$ \2 S# `6 v
对于新进来的数据,采用如下方式进行函数调用:
' q, V) @! r% B9 o& w* k; O; ]/ V x_test = np.array([[-3., -1., 4.]])
( l$ G7 |: Z7 Y: } x_test_minmax = min_max_scaler.transform(x_test)& w# A% o: ^' d
x_test_minmax & J$ T3 `7 ^: _3 i
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. 3 n& a* B8 _! G- y7 F$ Y
max_abs_scaler = preprocessing.MaxAbsScaler()
- f W# i$ ^, e x_train_maxsbs = max_abs_scaler.fit_transform(x)7 e( k, _; E% R. F. L
x_train_maxsbs ; E8 n! w4 k# o: A3 B& P. q
# 同理，也可以对新的数据集进行同样的转换
( J; p4 I: e4 Z K8 c6 @ x_test = np.array([[-3., -1., 4.]])- {$ C, G$ T1 I
x_test_maxabs = max_abs_scaler.transform(x_test)
8 u1 s- Y+ a5 [: R9 j" F; r x_test_maxabs
& b) w6 d5 {5 X$ a$ S0 V% |& H 针对规模化稀疏数据
6 N D- A+ j, Y0 a& J 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
" P% D3 v# Q3 } y$ ?1 G MaxAbsScaler,和maxabs_scale
* g2 H S2 Q6 J: G 针对规模化有异常的数据6 L- K% I8 j @3 A1 V3 B
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. . [ t+ h' H [* t
正则化Normalization; x. u* B- }( S* D% w
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
/ P/ R- u) H8 |* ~ l+ l x_normalized = preprocessing.normalize(x, norm=l2)
- a! ~& M3 p0 U# o) r: k$ q print x8 M5 H- ]3 @4 w' u d
print x_normalized 0 ^2 o3 z# ?0 g7 k
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) * L4 e. J% l9 \0 U+ p. T( ~6 e
normalizer = preprocessing.Normalizer().fit(x)
B8 Y* c6 X7 ]( w normalizer
' |! f g+ k8 O4 |$ j* n2 y: u # 对训练数据进行正则
l: R8 S; v, {% Q/ x normalizer.transform(x)
" E3 I& n% `3 E! v # 对新的测试数据进行正则 " @# h2 N9 {/ s& G: Y( X# _
normalizer.transform([[-1., 1., 0.]]) ; \* ]9 Y# Y# p" D
二值化+ }2 t! H2 k7 w% r: i, y3 t
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 * u# X/ n$ z% P; ?# V6 C: Z' e
from sklearn import preprocessing: k) r6 F9 l" h
import numpy as np
* E) @+ d: Q+ z$ h
8 A" W! f% |+ K6 n/ c # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征4 e6 X/ }+ m3 @ E
x = np.array([[1., -1., 2.]," f; m" q3 r% |' N) N. p
[2., 0., 0.],9 q7 E' p; }6 G) E Q
[0., 1., -1.]])
9 B1 \0 a! A" j% W8 V% C. h, n3 W9 b# g1 E" A8 _" e* H) u
binarizer = preprocessing.Binarizer().fit(x)
9 L8 R1 u- t: P" ~$ C6 M binarizer.transform(x)6 t* m% q1 ~, z* J1 S7 C
7 K. ]9 N K$ N binarizer = preprocessing.Binarizer(threshold=1.5)
" b, z$ s8 M v( G) u% { binarizer.transform(x)
3 ~% f( k7 }) N1 v! d3 t' q" I* } 为类别特征编码* N% D) E3 \5 w" h3 ^( b
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
9 W" ^+ _% @' ^0 D _/ g OneHotEncoder `" J2 A3 x' @) j* v
弥补缺失数据0 M- S' d8 N# B% b# n$ V4 @9 S
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 5 a/ D$ F5 ~* Y* R/ ]" G* G! p
import numpy as np
0 y) Y6 D' \- e0 M1 m. w# m from sklearn.preprocessing import Imputer
) L) I. `' X7 [& j1 n8 l imp = Imputer(missing_values=NaN, strategy=mean, axis=0)+ Z' K2 Y: s7 e
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
7 w! l; O9 c. u x = [[np.nan, 2], [6, np.nan], [7, 6]]
: O. P& K8 G' `+ G! X! W! _: u imp.transform(x) # |) P8 ]4 _/ q
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
8 l8 z: `$ l7 O; `, ~ import scipy.sparse as sp' @# W1 O3 H1 D4 x! O, _. D
# 创建一个稀疏矩阵
p- D! p) Y. {9 v& G3 H x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])% a5 [; G. I; z; z1 j0 ?8 H" A
imp = Imputer(missing_values=0, strategy=mean, verbose=0)8 X. u' m% B% H/ Y: ^9 ?9 w1 m
imp.fit domain name is for sale. Inquire now.(x)
( U$ p2 h1 e. i' q7 ? x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])( t& D9 A# h$ J- W
imp.transform(x_test) ) ?- W7 Z/ P6 b7 ]: f& m
当我们拿到一批原始的数据 % d3 q5 `; l* k8 \3 I; h6 x' L* \
首先要明确有多少特征，哪些是连续的，哪些是类别的。
2 C+ I8 m8 m0 B 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
2 g# r! c+ Q+ n* ^, l( d 对连续的数值型特征进行标准化，使得均值为0，方差为1。
7 b8 E% x* \) `% \7 t$ u 对类别型的特征进行one-hot编码。
! v/ C# U: ?) I0 `+ K! k' { 将需要转换成类别型数据的连续型数据进行二值化。
) T' Q1 V. }$ j 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 ' k9 D5 B% E) z1 ?8 G: @+ I u- e
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 3 a3 u8 s# K: ^0 R3 e; w0 @+ B
根据实际问题分析是否需要对特征进行相应的函数转换。
. Q5 m% h. O( {! y2 Y 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ! r4 j: j; o% Q, q/ D
因此针对动态的数据可以采用如下几种计算方法:
. o+ D% T1 T7 e$ f2 D8 W 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 & a4 Y; O& \. M% o. T, W+ S
; J9 ^' @' d6 e/ M
5 Q8 \" i2 g$ b: }/ J
! n9 ~6 z$ I1 Z
1 \7 n. B& ]* ?: \7 p z D D5 y | 
