. U. S1 h2 _& d& f! I: F sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 8 Z+ A& [# j0 ?
归一化是标准化的一种方式,
+ p1 i5 |( {- M( L( F* J, N 归一化是将数据映射到[0,1]这个区间中,
: o$ l1 j* J' o3 U. N 标准化是将数据按照比例缩放,使之放到一个特定区间中, / \( \0 D+ r2 f3 L6 a
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
' Q' r5 H0 ]( I% @, } 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
$ x1 w" U+ x) e6 l) ` 导入模块: 1 ?& m8 I5 Z" D! N0 j
from sklearn.preprocessing import StandardScaler! r& j. m) p! M3 L8 _- G" u
from sklearn.preprocessing import MinMaxScaler3 m7 H1 q: P& n3 c3 w2 j
from matplotlib improt gridspec5 I/ n, \4 x( |' i, r1 |
import numpy as np
* U3 M* G6 O% [% O, | import matpotlib.pyplot as plt ! A7 Z; e8 w7 K
使用sklearn 进行标准化和标准化还原4 ]) B9 \4 p3 U2 j, D6 J
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x)
' a3 M1 E' w2 A. j2 y) } std = StandardScaler()
, P. i2 p# t9 S( `) g; u data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
) d ~, A* d( t' n
7 ~/ A. [, u; ^/ @ # 将标准化后的数据转换为原始数据。
# h; H$ L5 G: b2 I M std.inverse_transform()
/ Z+ d& }% f/ ` 查看标准化后的数据的均值与方差 5 p" W0 A5 \+ C5 Z
x_scale.mean(axis=0)# 均值
/ ]$ y5 t7 C" H7 }* W # axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作
: N1 Y( q Z* w x_scale.mean(axis=1)
/ }: Y. [8 S3 c# v& R `
* {+ H$ z$ t1 m( I: O. ^, p0 ?7 E3 x cps = np.random.random_integers(0, 100, (100, 2))
1 \& K% z- p* f6 f1 s0 K # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.9 H& _! y+ N- L- G. s4 i
ss = StandardScaler(); U9 ^+ C, V) J& d" H( n9 z) S
std_cps = ss.fit_transform(cps)
/ e$ C9 ?% {! ~; O, d1 i0 q/ |5 D gs = gridspec.GridSpec(5,5)
8 t& a0 D( ^5 h: G0 l% t fig = plt.figure()" }0 N. \3 L. [
ax1 = fig.add_subplot(gs[0:2, 1:4])
% Y" x2 S& Q; k ax2 = fig.add_subplot(gs[3:5, 1:4])
: W% T% l3 B! h1 G9 H; ^0 E% W$ k' O& n+ T ax1.scatter(cps[:, 0], cps[:, 1])) E; ]: L9 J/ G' k
ax2.scatter(std_cps[:, 0], std_cps[:, 1]), T( s$ p5 K: R. z' J
plt.show()
7 @7 S+ e' A" p1 E1 {/ I- j7 T `
; \1 E U: ~. t! o7 X from sklearn.preprocessing import StandardScaler
2 Y$ o7 l6 ? ^* Y( r from sklearn.preprocessing import MinMaxScaler/ J6 y0 k; |$ W, J4 h, t! d
from matplotlib import gridspec' B4 ~& p( n# V
import numpy as np
- X, h7 g: t" w1 S. i2 j import matplotlib.pyplot as plt: S. b5 P9 ?- s4 B7 P8 q
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
9 U3 B: r ?/ m$ n" m5 h ss = StandardScaler()* Z0 s6 J; U' p
std_data = ss.fit_transform(data)7 ^, N9 F t8 _2 s$ t' C7 U
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
+ F8 S' K% d% M. L c print(data is 原始数据,data)
" D6 u: I+ L4 ~7 Q- L ~0 H print(after standard 标准化后的数据,std_data)1 p1 X8 B3 a; C* e
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)) } G8 Q6 G7 \3 f
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) 8 O: i' J1 G) b5 ^1 [
使用sklearn 进行数据的归一化和归一化还原.0 T( n" T- }3 I7 Y0 }1 N5 b# v8 _. K/ ?* T
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
7 C! u' p/ z* R3 r" \, b. b mm = MinMaxScaler()# 创建MinMaxScaler 对象
# z( V f* K+ W mm_data = mm.fit_transform(data) # 归一化数据$ c! \; c% Z# r a& e
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据
5 B3 Y, ?+ h# {! V* ~) L+ \ print(data is ,data)( O5 V8 r4 @, c/ w
print(after Min Max ,mm_data)
9 u# [) s- P N" h5 h9 S print(origin data is ,origin_data)
, U: Y, K0 N1 @/ a1 V MinMaxScaler和MaxAbsCaler:
4 s1 t5 @% x( _1 q4 ?9 J2 @/ L MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
* w3 L& D# s) O: g MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 ; Q" J( y/ K5 a8 h$ T- b
min_max_scaler = preprocessing.MinMaxScaler()1 B8 K; ^0 N' Q g
x_minmax = min_max_scaler.fit_transform(x)# Y" @8 V/ @" P9 A* `
x_minmax 4 F, Q2 z( A# h! W( f2 v- D
对于新进来的数据,采用如下方式进行函数调用:
( j8 [9 m. \ s" s5 r3 p N7 m+ `# f x_test = np.array([[-3., -1., 4.]]) A( C" G6 W6 x3 q' ]' q
x_test_minmax = min_max_scaler.transform(x_test)* y4 A; y/ O' U* |
x_test_minmax
$ H+ u0 u2 o, N4 Q9 _8 [2 ] MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. ) k( x( L$ L& u9 F0 t6 \
max_abs_scaler = preprocessing.MaxAbsScaler()
% o9 ~' t6 i7 z# J- ?. t x_train_maxsbs = max_abs_scaler.fit_transform(x)
! L* s2 K `) @1 Z. M1 D( o7 H' Y x_train_maxsbs " x9 u3 V7 d) f! `2 t; B
# 同理,也可以对新的数据集进行同样的转换
8 \2 {' S8 N" u! }0 E x_test = np.array([[-3., -1., 4.]])4 o( D/ V" \* T- h
x_test_maxabs = max_abs_scaler.transform(x_test), x1 E0 }7 V& F
x_test_maxabs ( U- ^% o: S# P1 W% ^5 q
针对规模化稀疏数据
, c5 c! o m" e5 L! o( }( G2 d( Z 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
" r6 I& ^8 u+ L) ~! m MaxAbsScaler,和maxabs_scale
( S0 M$ T. b" _+ x( v' x& j$ _ 针对规模化有异常的数据; B* a( V% ^- o9 K1 i# s
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. ( ]2 o9 z6 {" ? b) i
正则化Normalization0 a: n7 X* U" H1 w) Q( ^
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 7 h3 R: ~! d# z
x_normalized = preprocessing.normalize(x, norm=l2)7 w2 ^- E8 }1 f) K) J E5 j
print x
* O8 q; |6 D0 Y+ t' @5 G, z print x_normalized
0 |* z' z- [4 y$ r4 }8 y7 C6 } # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
8 _9 E6 h6 ]( Z1 U X& J normalizer = preprocessing.Normalizer().fit(x)
9 |9 @2 B! D) V normalizer
" t2 L* `$ F0 ~5 C0 Q # 对训练数据进行正则 ) Z- J# n- F' [$ X5 t
normalizer.transform(x)
$ `; `& s7 X2 N: v # 对新的测试数据进行正则 - o& v$ c, o2 e6 R7 Q
normalizer.transform([[-1., 1., 0.]])
7 }0 R$ {' `+ h, q) ] 二值化
, P* k( W5 ?( c( r3 H0 @* g1 h 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 ' E. D: t& d3 u, Z
from sklearn import preprocessing* X; }7 l7 M, v0 Q! x
import numpy as np
& M. {, P0 Q3 B, O+ \8 R* a" i
) F5 z3 _( m; A/ [: x% ? # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征. o1 t4 |+ k F5 x* ~$ |* \- Z
x = np.array([[1., -1., 2.],% E9 v4 \8 I/ b5 T( C3 @! o: Y
[2., 0., 0.],
1 v2 D: L" f2 r [0., 1., -1.]])
* w. b% v" T* @0 _1 I
6 j4 i; U8 z5 S' |* @+ _ binarizer = preprocessing.Binarizer().fit(x)! W ~, I5 A; M6 {0 V
binarizer.transform(x)0 ^1 u i2 |( \; d# P5 S8 I4 J
( ~# _" b4 o# O3 M" \
binarizer = preprocessing.Binarizer(threshold=1.5)$ w! u8 h! E6 r$ |
binarizer.transform(x)
$ ?- I+ \7 G. F2 Q5 x3 V 为类别特征编码; ~" R" w. T% }# n
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. - g$ M8 f7 ^& c! n: h5 v6 _! }7 g
OneHotEncoder
, x9 R/ a" z# ~6 f2 R' A1 `$ C7 d 弥补缺失数据1 H- V1 B% R& v8 d7 V; Q5 f
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
/ Z/ L" ?; R* G# I( q6 ~& Q; I import numpy as np% T' i$ b, ?2 l6 ]5 f
from sklearn.preprocessing import Imputer T! ?% ~* T5 E
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
" s. q$ g3 q$ o$ o. Y imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
6 f+ o+ p( y1 b2 m# I& w x = [[np.nan, 2], [6, np.nan], [7, 6]]
j) y# E# p, p5 N0 e X5 s* c9 S imp.transform(x)
! k1 ]4 i, X, L% W Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值
) H- \1 ? d9 Z) [2 y: d, k import scipy.sparse as sp4 @6 v: x6 ^& u" R, ~
# 创建一个稀疏矩阵9 R: Y# r3 V+ d2 B3 i$ \) D
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
! _+ E1 W/ I3 M' v$ u, v imp = Imputer(missing_values=0, strategy=mean, verbose=0)
1 b ?* p' q7 p3 x( u d imp.fit domain name is for sale. Inquire now.(x)( i; X5 Q! I1 I/ _0 w8 o
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])% F6 }' I- E- D% }1 _# W
imp.transform(x_test) ! ~2 F/ c6 Y4 ?) I ^6 N# S! \9 O
当我们拿到一批原始的数据
9 Z. t# S2 n4 _; h2 Z 首先要明确有多少特征,哪些是连续的,哪些是类别的。 6 O9 X. ]! A, M5 r9 p
检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。
# q0 x) `9 l; a$ Q- J0 O1 v: ? 对连续的数值型特征进行标准化,使得均值为0,方差为1。 ; e3 {8 b- B1 F" i
对类别型的特征进行one-hot编码。
) q4 F9 }- X& E3 K4 j. E* h 将需要转换成类别型数据的连续型数据进行二值化。 7 t% t" ^ i: y1 {! D8 A" H
为防止过拟合或者其他原因,选择是否要将数据进行正则化。
! E. \! A( J) ~0 D/ ?- W6 f9 Z 在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。
3 w7 o4 Y* ^% v. H% c% r! @- z 根据实际问题分析是否需要对特征进行相应的函数转换。
2 p2 k$ X4 I7 j, V" @ 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 8 b$ G+ e4 }' m2 Z
因此针对动态的数据可以采用如下几种计算方法:
. s. q5 W& [7 U" p9 ^ 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客 4 `! K) P' \ g" j9 y r& H8 h
! s2 q: T5 e6 M, u) r' a2 Q" D2 ~7 h# g
4 d8 A. o; `8 u0 X+ E! V
% r* d: |$ |; L+ ?0 O
|