|
- f# h3 ~% M i sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
o {8 t9 Y; k- s# L9 ^: o: @* k0 }1 } 归一化是标准化的一种方式,
9 M' D3 v# U, X7 K/ S 归一化是将数据映射到[0,1]这个区间中, 2 [# |0 D5 A- ^7 `6 Y8 n
标准化是将数据按照比例缩放,使之放到一个特定区间中, & V5 d+ c* h3 @
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. / x& G& x2 P6 ^* ^6 x+ I2 S' |! m6 ~
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) }2 I9 x4 y2 a A& y
导入模块: ) }9 s2 i# R; _) X; _
from sklearn.preprocessing import StandardScaler8 V- ~4 y6 w8 U) b4 ~8 ^/ ~3 Z
from sklearn.preprocessing import MinMaxScaler
4 G6 S* Y0 j* @' c from matplotlib improt gridspec
! M% c0 W5 x2 I: e import numpy as np
3 H0 J( p: Y' G6 v# l import matpotlib.pyplot as plt ' G. r1 H: n/ E2 R; c
使用sklearn 进行标准化和标准化还原- {; ^- J& G# j, T& D2 l, @, a8 ?
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
( z$ u9 z( Y- h' R5 r9 e std = StandardScaler()/ @6 `, M+ k7 D: V' O
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])& H- W, I4 G4 Q0 j
- b4 H$ G% U A
# 将标准化后的数据转换为原始数据。( A8 h! v: v. p* u* O8 E
std.inverse_transform() ! q. }# ? N, ^- R
查看标准化后的数据的均值与方差 . d8 a4 w4 Q( F( V [
x_scale.mean(axis=0)# 均值
( i- R& {6 {1 j/ v V3 u # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
% \" e1 ?" D# D% {/ V# I! c! p2 r x_scale.mean(axis=1) 8 M' Q9 E. r5 Z0 ~: h5 _5 a5 y2 ^
` + T1 l& z. y. ^6 x- v2 ^( B" U
cps = np.random.random_integers(0, 100, (100, 2))
( Z2 w& Z6 d; h # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
2 m1 p% g' X' O w" X5 b) N ss = StandardScaler()4 o+ j/ }: {' z) D! q6 L+ ]0 J' o6 q
std_cps = ss.fit_transform(cps): B5 _' Q+ W2 y* q: \$ r e
gs = gridspec.GridSpec(5,5)
0 f6 _9 r9 d) X4 e) _ fig = plt.figure()
9 g8 l4 O, t/ k: x ax1 = fig.add_subplot(gs[0:2, 1:4])
0 L- q! s) u' @5 ]. _ ax2 = fig.add_subplot(gs[3:5, 1:4])
5 i# A. g- j s1 J) v ax1.scatter(cps[:, 0], cps[:, 1])9 N) S* M. B, Z
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
1 ~, f& f6 I, C* D I plt.show() d6 |3 i; s+ P. T Y% v% q$ V
` $ _4 T7 Z- Z/ ]+ B. a% V
from sklearn.preprocessing import StandardScaler1 _* d7 O$ A: W) l5 A
from sklearn.preprocessing import MinMaxScaler3 R7 A' J8 \5 i! H, p: A- ~6 x
from matplotlib import gridspec9 A6 Y, @7 Q+ f; @) m F$ g; B
import numpy as np6 Z/ l' m8 E& i. |( ?
import matplotlib.pyplot as plt
* E* p1 G+ m) C data = np.random.uniform(0, 100, 10)[:, np.newaxis]& Y y! e3 p( u
ss = StandardScaler()6 p3 _* _# o0 _- V# r8 |
std_data = ss.fit_transform(data)
- g" ?' Q$ h( s% K origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据" [, w8 B0 T& A# {: e
print(data is 原始数据,data)- Z% K9 F+ R; ?' v
print(after standard 标准化后的数据,std_data)) R1 a7 @* L$ j
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
% L- T$ q3 F3 T3 D; Z/ N1 X2 q print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
5 x* a" }' S) l- |% V1 z 使用sklearn 进行数据的归一化和归一化还原.: b# o# `, A1 G! ?
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据5 l c, l; M1 w. y' m6 p
mm = MinMaxScaler()# 创建MinMaxScaler 对象: v4 m1 h$ n- a2 F+ H4 q& v/ p
mm_data = mm.fit_transform(data) # 归一化数据, W. q+ E9 x# `( y: |0 {! J7 [
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据7 R2 r6 u! s7 A, M# }7 v. ]
print(data is ,data)6 N, i2 f* k0 r; r) C) d
print(after Min Max ,mm_data)8 w3 p2 n' I9 x9 L i/ Z3 X8 G: {
print(origin data is ,origin_data) * m, d" U% U5 M, c# @2 G+ D: |
MinMaxScaler和MaxAbsCaler:
* i: T7 y, K3 a: I! X( c MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) 1 g" B2 N5 n- t
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 3 J- k1 P7 t; ?
min_max_scaler = preprocessing.MinMaxScaler()
2 p' D) \; f- V. m5 ?1 r x_minmax = min_max_scaler.fit_transform(x)
* v/ P4 r( c5 W x_minmax " w- t, u+ Y, I- m
对于新进来的数据,采用如下方式进行函数调用:
5 P* w( g) n0 @% L% h x_test = np.array([[-3., -1., 4.]])
5 l2 I1 N5 t; q" R; ^8 j x_test_minmax = min_max_scaler.transform(x_test)
' t% \( I; X+ `& [4 h8 ` x_test_minmax ) V7 R) R# \/ p( A8 C
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. 1 c$ [9 J2 r$ b( t( w* f p. P* c
max_abs_scaler = preprocessing.MaxAbsScaler()
: f9 ?# I2 d1 v9 s x_train_maxsbs = max_abs_scaler.fit_transform(x): u! ?- H4 X) D) R- i" O
x_train_maxsbs 2 A4 m- H, |) K! M& h) J6 ~
# 同理，也可以对新的数据集进行同样的转换 ( ]$ {/ O I$ L( B" G: i
x_test = np.array([[-3., -1., 4.]])
2 C/ T" \- z+ `+ `# O& k3 V/ z: U x_test_maxabs = max_abs_scaler.transform(x_test)/ V6 r+ [; j. c3 A1 b# w) t
x_test_maxabs e |4 L" A% y: P
针对规模化稀疏数据' ?; I: e1 C& |# F7 V
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: 1 y, M# e1 |) b6 f. T
MaxAbsScaler,和maxabs_scale * |, t; m: @% C
针对规模化有异常的数据
: E; A) {! Q, f7 w$ {+ N" m6 I. L 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
7 L8 R5 S1 h4 w 正则化Normalization6 h% y8 E7 k* A ?5 A; {
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
8 G2 H( g2 p% O9 A x_normalized = preprocessing.normalize(x, norm=l2)
6 R) Q0 F; g* g- W! w+ J- r print x' J4 ?3 W4 a8 q7 j$ V
print x_normalized
' O1 i; i) ~" X0 f- X, l% F8 } # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
. G. H2 y& M3 ?, [) E+ k normalizer = preprocessing.Normalizer().fit(x)
e( d7 C7 X- s normalizer
9 c2 Z* Q7 c' g" G# L! J # 对训练数据进行正则
9 j% r; g5 b6 \+ ]( f normalizer.transform(x)
$ t8 m! ?& I$ ]. d* J2 z9 W # 对新的测试数据进行正则 : `! I e1 W! \
normalizer.transform([[-1., 1., 0.]]) " [+ R! | n/ ]2 F' o
二值化6 `9 U0 X( o( m$ p z2 ^
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 1 o/ w+ b) N- r( [& W5 @
from sklearn import preprocessing
. U, L7 A. j! j! { import numpy as np
8 n$ W1 K c% I' ~0 H- {* p
; T( Q7 r' p4 I: l # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
6 A$ N7 j& I6 q+ a x = np.array([[1., -1., 2.],3 ^& `$ ~ l0 B7 e
[2., 0., 0.],
0 ?0 a6 Z. W7 \2 ]( h' N9 x" e [0., 1., -1.]])
( ?5 ~- _( }5 {, n/ O. F
4 ]8 I8 q0 M7 C" m, j binarizer = preprocessing.Binarizer().fit(x); W3 T8 R! z1 i+ m
binarizer.transform(x)$ A U+ t7 o, E `9 g* k
! ^0 A3 r+ M0 |
binarizer = preprocessing.Binarizer(threshold=1.5)
1 R$ G+ k7 @) e8 F binarizer.transform(x) ; `: B% ~' t5 w1 n s' C$ ~6 a% V1 v2 V
为类别特征编码
5 m) c1 w6 u, c* t1 h/ J (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. + ?; N3 O, O$ ?% D/ d
OneHotEncoder / R: M7 N$ l! y4 i: H1 l
弥补缺失数据# y Q/ ^- t1 r& K& `% H, X4 w
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. ' I- [. D1 T, a( m
import numpy as np7 B: Y3 q" t- l- M4 v
from sklearn.preprocessing import Imputer
" Q& b6 K! R/ Y! A: U imp = Imputer(missing_values=NaN, strategy=mean, axis=0)! D) C$ G. Z+ x. i! V6 f, J
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])- C- Z% \& p* B. }8 W
x = [[np.nan, 2], [6, np.nan], [7, 6]]
5 O' f: @7 E( Q% Q imp.transform(x)
6 n5 G0 X2 k+ r3 p7 u7 b Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
# [! `) H0 I$ a$ t0 L4 t- e import scipy.sparse as sp
% }1 o1 @) j- g J* \3 x # 创建一个稀疏矩阵/ D& @" z$ p+ n5 ]; N' o( T% k
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])1 v9 ]0 d8 ~+ k9 R7 H" `% I# u
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
* w/ \6 ^% p% {( Z; F7 X( Q$ B imp.fit domain name is for sale. Inquire now.(x) ]1 b3 D4 k1 o& p
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])4 X3 O- [5 e$ C( \$ T
imp.transform(x_test) ' u/ Q" g4 t# V3 E
当我们拿到一批原始的数据
8 L$ d3 `3 e, [- t$ j 首先要明确有多少特征，哪些是连续的，哪些是类别的。
! ]$ [/ U/ ]8 V+ k X' N0 I H9 W 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
* w& X( x- I: K5 b 对连续的数值型特征进行标准化，使得均值为0，方差为1。 7 Q& Q; W3 R+ }' c! [) j
对类别型的特征进行one-hot编码。 + |3 s J7 q" u% t
将需要转换成类别型数据的连续型数据进行二值化。 8 U' T- ?+ J; E7 T/ d) v2 ]! d
为防止过拟合或者其他原因，选择是否要将数据进行正则化。
/ F2 K* `* k" h. _8 z" V 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
' o, m" p& V: G4 U7 s: j; P 根据实际问题分析是否需要对特征进行相应的函数转换。
1 j, c C) ~/ }) p% u 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
# k5 L1 o5 F0 T+ F0 g8 \ 因此针对动态的数据可以采用如下几种计算方法: * a p& O& h" I5 ]. P8 Y
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
9 M% ^, L0 \; v$ \+ `' R% s2 s
/ m0 K' D& h) Y5 x/ a
. |! J& z! i3 `
3 T( X2 |7 ~, c- f* O3 _, q$ u; R. U7 b" j2 U
|
