|
4 x+ G- Q3 ?3 {. M7 j sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
& F4 d9 F% n) w1 Z* d4 X- e! v 归一化是标准化的一种方式, 2 h1 ~$ h4 |* p5 E+ O" D& M
归一化是将数据映射到[0,1]这个区间中, ( n* m" }' I5 ^! A2 v
标准化是将数据按照比例缩放,使之放到一个特定区间中, # @0 B) h$ a E1 a
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
1 p' O- K6 Z' I5 ]( ^% w, J 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
7 E# K8 Q3 w% O 导入模块:
$ Z* r& l$ p) p2 T9 R1 C" ^ from sklearn.preprocessing import StandardScaler! j/ i7 j1 v9 R. B+ }
from sklearn.preprocessing import MinMaxScaler+ i/ F( [2 e: |: H) C8 X) Q
from matplotlib improt gridspec9 P9 d) O3 x( y
import numpy as np' _# o, }8 z0 `2 b/ C& j
import matpotlib.pyplot as plt ) O6 V. u5 @" _) E* P
使用sklearn 进行标准化和标准化还原7 T* k0 ^/ ~, M5 k! ~. l" N8 l
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
0 ?8 |$ Q$ E4 w# I3 t9 m/ a std = StandardScaler(); \8 w6 a, R' a0 c3 v
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
: `( D5 W/ v; B! t! ?8 D
: Z2 P5 ]( S B # 将标准化后的数据转换为原始数据。
5 o, v! J$ r3 J4 P std.inverse_transform() 5 K8 \, \0 N( g3 y
查看标准化后的数据的均值与方差 ( X- n- m$ }8 n6 x9 p8 a5 b6 X8 |
x_scale.mean(axis=0)# 均值
) V' x' q5 w1 c # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 * q4 K6 }! f7 s0 R" M
x_scale.mean(axis=1) 8 C+ D: {8 j% m+ t) F" H
`
# |6 ?4 B4 ?! I0 ^5 G cps = np.random.random_integers(0, 100, (100, 2))
9 T# s8 w1 s: S3 S # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集. e( ?) Z7 y0 J! V7 l
ss = StandardScaler()
3 s1 |* f5 ]8 ~ std_cps = ss.fit_transform(cps)
$ C! f4 G. T6 d gs = gridspec.GridSpec(5,5)! R- K( {1 V2 y9 X# \ c
fig = plt.figure()
+ t8 {4 J& G$ {% [- ^0 M) }) J$ [ ax1 = fig.add_subplot(gs[0:2, 1:4]); U0 f/ }2 F* o+ A7 q" D6 ~
ax2 = fig.add_subplot(gs[3:5, 1:4])
( e3 s- t7 Z4 E( } ax1.scatter(cps[:, 0], cps[:, 1]) n+ e! H5 A% m' j0 Z" o
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
" u. a" r+ o& e/ @ plt.show() & {5 ]; D# p2 e) m
`
0 J- }: X% O; G$ F from sklearn.preprocessing import StandardScaler
2 I q* H1 j' C, d! d from sklearn.preprocessing import MinMaxScaler% W( O/ g' N1 z* z/ a6 \$ Z& g4 R
from matplotlib import gridspec5 F7 Z0 U, @8 I3 A1 Y4 U) `
import numpy as np, @ P& j) N% D+ ~1 f
import matplotlib.pyplot as plt
6 R: @1 P5 m" X7 r( P data = np.random.uniform(0, 100, 10)[:, np.newaxis]
3 W0 y7 f. S6 j) @! Y) u: ] ss = StandardScaler()+ g; S. O* h7 r
std_data = ss.fit_transform(data)/ _; E6 E$ S4 x/ S$ W* b. N% p% C
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
, ]$ a; i( H4 V1 [/ j/ n print(data is 原始数据,data)/ g6 D' `( y0 A# w3 j& h# h
print(after standard 标准化后的数据,std_data)
8 a6 h! T9 E3 Q! T; y5 m! \, X" Y print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)7 C/ y% } U4 y! }8 F9 m/ z# p. I
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) " H/ H) d5 s, t0 p! x" z
使用sklearn 进行数据的归一化和归一化还原.
! o# y7 G$ S( s0 f0 q! Y0 w9 ? data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
+ U3 r4 H( \8 J$ {4 g5 a5 N mm = MinMaxScaler()# 创建MinMaxScaler 对象% L# C5 r/ U. ~; i& u! _% y
mm_data = mm.fit_transform(data) # 归一化数据
! U" O& S8 C/ o- }: i origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据1 S9 T u2 y1 S# h6 i
print(data is ,data)
- v9 S! K( o' p2 l8 G8 s: m print(after Min Max ,mm_data)
) _$ B5 I5 D) J$ m: Z/ P2 b print(origin data is ,origin_data)
3 I0 w# h" E4 e1 m6 A4 c: P MinMaxScaler和MaxAbsCaler:
1 j. v% I1 ?7 z" t! N* _. ? MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) ( _& M9 e: a& g8 d6 Q
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 8 R- n; K# ^6 \7 T) v1 a. w( k
min_max_scaler = preprocessing.MinMaxScaler(); F& s) z/ O9 ^1 g! m
x_minmax = min_max_scaler.fit_transform(x)
* W6 g/ D( `: n& l3 T, T2 |" \ x_minmax , i% G+ [3 F5 O$ a) w
对于新进来的数据,采用如下方式进行函数调用:
% I9 b; f W0 s: a0 }$ ~ x_test = np.array([[-3., -1., 4.]])
% y7 n0 e# j+ ~/ T' j x_test_minmax = min_max_scaler.transform(x_test)
: `, D. T) W8 [+ A; ?1 A x_test_minmax % I/ g; n @. l" ^
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
}" h' _2 S) s5 a2 y8 v0 e" v: Q max_abs_scaler = preprocessing.MaxAbsScaler()& D9 E/ c4 G V6 p$ m& X- K9 B5 m+ n
x_train_maxsbs = max_abs_scaler.fit_transform(x)- ^' d2 p. ?+ s. P1 [/ Z
x_train_maxsbs ' l# ~: C- _: A6 f0 m
# 同理，也可以对新的数据集进行同样的转换
* w. n8 ~7 p7 K1 y+ D q: Z$ X x_test = np.array([[-3., -1., 4.]])
# B7 U! J2 a ? u# Z d% b' c- { x_test_maxabs = max_abs_scaler.transform(x_test); C" f% Q s: {2 R
x_test_maxabs 6 Q2 ]; B% C% Y
针对规模化稀疏数据. {' t/ n1 L- z6 \
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
, G3 `$ O7 U1 N% m1 |4 E MaxAbsScaler,和maxabs_scale 2 Q9 g+ W- q2 ], M9 k7 d9 D
针对规模化有异常的数据
" Q: f1 A& v0 a 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. 2 ` }6 U2 O' L! v
正则化Normalization8 Z3 R5 R% ?# P- Y: ?! K4 N( ~2 ?5 q
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 + b6 {3 }$ d8 ^$ R4 ]6 K
x_normalized = preprocessing.normalize(x, norm=l2) S, q( A) h. |" r8 w, f- p' k
print x4 l" y+ J+ `2 X1 m) N
print x_normalized
, x( @4 I. O( ]( Y" K: R # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
) T- Z" I/ S. [! T+ T9 H2 L normalizer = preprocessing.Normalizer().fit(x)
6 I! r! {6 O' h0 f normalizer
0 m. W n) S* t! i. G* U # 对训练数据进行正则
4 C( H7 S0 c( a normalizer.transform(x)
: u& V, w1 d+ P7 }. F; @( P # 对新的测试数据进行正则 ) _0 z0 I5 W0 m7 G0 X5 A9 B
normalizer.transform([[-1., 1., 0.]]) $ K: x7 O7 b& J- S1 Q& `4 @
二值化" p4 M2 w1 j v- B* K r9 [! ?) m# J
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 2 r$ v8 ?0 R3 u$ W& Y+ o
from sklearn import preprocessing
7 D+ }- U( S3 R; `2 W import numpy as np
& {# F! J3 a9 U K/ z
: O% }5 X! l, X; p' _2 K2 M # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
1 l W! Q: H& M0 h: K) q x = np.array([[1., -1., 2.],' H' r/ M5 ^# C
[2., 0., 0.],
% U+ P$ s2 f7 w9 Z [0., 1., -1.]]) h$ D$ ?1 S" u0 e
4 Q. ]4 j2 \0 d6 o, r binarizer = preprocessing.Binarizer().fit(x)7 J" A5 s& H( Y1 _* A7 n
binarizer.transform(x): e: Q1 p+ T* w7 s
4 T5 f% ~4 u# z% i ^$ U( \* l binarizer = preprocessing.Binarizer(threshold=1.5)3 G; K8 F! _3 {
binarizer.transform(x)
8 o' ^! n, Z. @2 j4 Z6 D6 Y 为类别特征编码
, K/ R. h# m! n4 l8 H (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. , X0 |/ ?0 k9 C5 }& L
OneHotEncoder
+ _( O: c! F% J% b 弥补缺失数据
9 }$ o7 ~2 v$ w; D 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. / f) |% z, y+ z
import numpy as np+ o* N, J, A2 C5 E2 d, U
from sklearn.preprocessing import Imputer
% J8 [/ T+ |# W) Q6 }; g imp = Imputer(missing_values=NaN, strategy=mean, axis=0)5 z0 [- I6 q6 W2 a+ |, y' Q6 {
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
T9 n( N/ }/ X- U7 G p2 j5 v' x0 V* C x = [[np.nan, 2], [6, np.nan], [7, 6]]- N) w- c. B, p, a
imp.transform(x)
, b9 ]) @( \6 P' C! X- d) y9 ]* m" M+ { Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 6 ^$ H% F! j( p$ z; y( i
import scipy.sparse as sp
' z; n$ V- K3 W3 m1 A$ t # 创建一个稀疏矩阵
2 A( A( b! w6 L6 D$ R x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
) P, Q7 s' Z2 I# P imp = Imputer(missing_values=0, strategy=mean, verbose=0)7 f- k% a1 F- z& h' j, S9 @
imp.fit domain name is for sale. Inquire now.(x)& J3 }9 K9 c. p3 J/ `
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]) P$ d; ?9 V$ m. b- l
imp.transform(x_test) 3 h( K! e% \: u& J B
当我们拿到一批原始的数据 1 {+ q3 h9 `5 |; b: Y0 i
首先要明确有多少特征，哪些是连续的，哪些是类别的。
& Y. L9 M$ B3 t, W( C 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 : T5 y V1 B( b8 m' D8 C- a
对连续的数值型特征进行标准化，使得均值为0，方差为1。 * n2 Z2 Y* _: C" i
对类别型的特征进行one-hot编码。 3 l N. ^+ |$ E* N6 v1 ]. L, _
将需要转换成类别型数据的连续型数据进行二值化。
3 r2 Y* f5 J% @: U& C4 T 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 ! i% m' ~( |- h
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
; i, M# z# v$ X' B9 E 根据实际问题分析是否需要对特征进行相应的函数转换。
" e1 k: l4 c+ @' w/ k 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 4 l& m' _; O9 D6 f" v! J, ~
因此针对动态的数据可以采用如下几种计算方法:
. z- D2 k, Q8 b/ P) O 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 8 W5 a7 M& o Z$ B' g
7 ] c7 i; j3 ^2 z2 v; h
" u% b0 s* J& ~; U0 i* w6 x) K F# _ ]: g
& |, y3 C8 N; e9 V2 A" z/ n* U
|
