|
, ^! i( V6 B5 [+ {( [' U sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: ' ?. l, L2 A0 L/ `' d
归一化是标准化的一种方式,
: ]/ d; V! h: {+ V/ B/ C+ n; e 归一化是将数据映射到[0,1]这个区间中,
# L5 P8 I: K U1 M& F/ J% r6 ? 标准化是将数据按照比例缩放,使之放到一个特定区间中,
' |5 U: }. X5 i" E* g7 x 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
; \- v- ^+ h0 k2 s 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) $ ?4 i+ h1 e- K5 t% ?
导入模块: ( \/ I2 P6 @8 I, \ W
from sklearn.preprocessing import StandardScaler/ H/ y. n, P5 l' c. N3 X0 U
from sklearn.preprocessing import MinMaxScaler
, [+ C* v0 A ]( m4 x& s from matplotlib improt gridspec9 `, P/ ^/ U4 ^2 _( s1 W
import numpy as np& ~2 f0 y, [0 q5 [) o
import matpotlib.pyplot as plt
8 h! ~ V1 L, N( v 使用sklearn 进行标准化和标准化还原
: w. R* j9 H- S% s; Q2 j; B 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x) ' D6 K: S5 J+ P9 s; ^
std = StandardScaler(), f% ?( k* \: l
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]): K* i8 {1 v+ U3 j) d2 T$ ~
& a9 g8 r$ }6 @1 T' |# C # 将标准化后的数据转换为原始数据。
$ G2 B$ ^$ \$ H std.inverse_transform() 6 p" i8 |1 e! {7 h$ [
查看标准化后的数据的均值与方差 1 h- f# U8 @4 F( y% o! g
x_scale.mean(axis=0)# 均值 8 v8 q9 l" q0 Q! f
# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作
) n) ~ n; A/ R. y6 M x_scale.mean(axis=1)
" l- `* S# B1 j0 r1 [ ` % b6 w& g6 ~- n1 P
cps = np.random.random_integers(0, 100, (100, 2))
4 H3 I! j9 v! M! j' ` # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
/ O! c" o; p+ H8 { ss = StandardScaler()
; i; M# x% i$ a std_cps = ss.fit_transform(cps)9 Z/ F9 a3 K0 K D
gs = gridspec.GridSpec(5,5)
; G& [% j' b6 w fig = plt.figure()
% }. T6 d! u1 E2 M8 s+ |$ g+ T ax1 = fig.add_subplot(gs[0:2, 1:4])5 M3 n8 q, A, K1 x' c
ax2 = fig.add_subplot(gs[3:5, 1:4]). o% H. f S/ b$ V5 W
ax1.scatter(cps[:, 0], cps[:, 1]); z- p; G, K, p3 h$ @+ U
ax2.scatter(std_cps[:, 0], std_cps[:, 1])2 p: T, s4 p4 Z
plt.show() 3 S1 X0 z/ u* t8 k* Q
`
1 B3 a4 V5 A% W9 H1 h from sklearn.preprocessing import StandardScaler
6 `' Y9 a" Z2 ^, I from sklearn.preprocessing import MinMaxScaler
& r' Q: h" g% [+ V" M% I/ g from matplotlib import gridspec
2 [6 e2 \) e) H# g" X5 B import numpy as np: C- Q+ Y9 d3 @) J0 V7 X, Z2 Q
import matplotlib.pyplot as plt S( W2 N5 m" m' o- Y1 ]6 G" D
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
7 ?& @$ d4 U3 n3 w ss = StandardScaler()
1 T. \ D, P% S std_data = ss.fit_transform(data)& y+ V% u6 U. z- _& Q8 O7 v; N
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
& N8 }4 ]: W+ \1 {; l print(data is 原始数据,data)
0 ^5 I/ V; I0 D4 N2 J+ p; H' c6 g print(after standard 标准化后的数据,std_data)
0 D6 _; p* W1 ^6 _% m. D print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
% l6 o4 Y4 i- ^4 T0 j print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
2 u, {8 [ Y5 H: L5 l 使用sklearn 进行数据的归一化和归一化还原.- U$ [( v& H" D0 z& k8 r
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
$ p! A; N9 }, @5 l1 q mm = MinMaxScaler()# 创建MinMaxScaler 对象
) L9 [! d3 C0 _ X9 ?: {, G N) ]& l mm_data = mm.fit_transform(data) # 归一化数据- j0 n! W! q- V) F& ^6 X
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据7 o, r3 L: p* `4 L4 L- w9 s& B7 J
print(data is ,data)
+ _' ~2 }0 W# F. Q7 J1 }6 T' k print(after Min Max ,mm_data)
* v, i+ t; k; [/ r) R8 {& y1 o1 Y print(origin data is ,origin_data) - w' N9 l. c) x% n5 }) A! z
MinMaxScaler和MaxAbsCaler:$ T$ b; x8 J; b3 G) t
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) * a5 `2 ~3 b, Q) A
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
" G4 _1 d+ K7 t( { min_max_scaler = preprocessing.MinMaxScaler()6 F$ k% ~, Y1 b
x_minmax = min_max_scaler.fit_transform(x)
- X& B4 z! [0 C: b/ ~ x_minmax
* D6 x8 x. V/ z, N, J; t 对于新进来的数据,采用如下方式进行函数调用: # H3 v8 h2 H$ \
x_test = np.array([[-3., -1., 4.]])4 j2 L2 P% y- d4 k$ m2 C1 L
x_test_minmax = min_max_scaler.transform(x_test)
+ _7 J8 ~! ?6 ] x_test_minmax - f) H$ [$ [- \5 P6 `
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
% x4 }& q0 M) a" D* @; r* ` max_abs_scaler = preprocessing.MaxAbsScaler()
; k M7 E& ^8 D& D# q2 M x_train_maxsbs = max_abs_scaler.fit_transform(x) R& I6 X @$ h/ Q5 l* `- A
x_train_maxsbs % p l4 a; m- s: k
# 同理,也可以对新的数据集进行同样的转换 + m a z, c1 }8 e
x_test = np.array([[-3., -1., 4.]])- o' @$ x: S4 k1 C! w
x_test_maxabs = max_abs_scaler.transform(x_test) Z& z2 ], n p* `1 y: P7 J
x_test_maxabs 1 H a2 v$ O% c! p' H
针对规模化稀疏数据
2 D( v$ @" |' Q/ K 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: : V* V* h! p' m8 l
MaxAbsScaler,和maxabs_scale
3 S7 o. ~0 R2 X/ r 针对规模化有异常的数据$ a, @" D/ O6 I. {2 _
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
2 N3 v$ V) C* V! w 正则化Normalization
6 ]( S* T; h( e 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 ) s( I. S- V* X$ R7 R
x_normalized = preprocessing.normalize(x, norm=l2)
5 c2 d' Z2 @: `0 s# v print x, U9 H0 N) a* ?( w& ~
print x_normalized 8 s l0 c+ }) W$ o/ l/ |2 `
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
1 y; J! r7 k/ G' F6 [9 N normalizer = preprocessing.Normalizer().fit(x)) j; h9 a2 ^* r! t$ u' r
normalizer
0 u+ ~: ]0 e& P$ f # 对训练数据进行正则
' C. q8 X. Y9 }3 F normalizer.transform(x) 3 z8 E( x e* S0 x$ D
# 对新的测试数据进行正则 ; [' V8 A; |; h2 q
normalizer.transform([[-1., 1., 0.]]) + I( o6 A; h9 o' J4 X
二值化7 {. B6 b* t$ k+ P7 }/ f
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 4 k- F! W* N8 }( u' }* l
from sklearn import preprocessing
4 e1 {& @, k( Y/ B import numpy as np& d6 i/ o3 ^9 [' S5 y' U! p
2 `+ E8 V+ G, z3 d # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征
' L* I; R& a. E# Q: V& ] x = np.array([[1., -1., 2.],
4 M: P! Y- d! w) F/ z [2., 0., 0.],
1 K u/ ?" _+ i7 b9 T# t) ]0 Z [0., 1., -1.]])- \ \& v7 r( n5 F3 S' W( e
% v: [ {; d6 {+ s' o9 e
binarizer = preprocessing.Binarizer().fit(x)
6 f. F+ l$ p5 v( H. ^ binarizer.transform(x)2 S: f: c( M) ^' W8 C' N. A2 Q
5 p5 V1 r# Z6 V1 i5 k binarizer = preprocessing.Binarizer(threshold=1.5)( O0 o- e) h2 g1 Q3 y
binarizer.transform(x)
v0 I$ ~# O4 {6 c, B1 ~ 为类别特征编码
) `. z! D# x$ }, u (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. + R6 }4 g m" a7 c
OneHotEncoder % W6 N# H I' R9 Z
弥补缺失数据
0 M( j2 |# n! B6 D' p A 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 3 l9 V( ~0 @$ g# l; e3 L p
import numpy as np2 F. H' b8 ]! {# }* t K
from sklearn.preprocessing import Imputer
) {% ~( X% R3 D8 J" W imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
. P( A+ W8 N9 U' T; j imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
% z: d5 k4 |1 D2 w8 K x = [[np.nan, 2], [6, np.nan], [7, 6]]
& _- |! F0 |' Y+ ~4 i6 |8 `5 e+ I+ L4 P imp.transform(x) * ?* S9 d: z' O v. j5 `3 W
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值
( }; B. K7 }; l4 s$ s' @% D' x import scipy.sparse as sp" M8 z- N3 ?5 n
# 创建一个稀疏矩阵
7 K7 H1 @/ }) f' }1 h& L x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])0 k2 {! i2 G- |
imp = Imputer(missing_values=0, strategy=mean, verbose=0)% P6 t3 s& X# t: S& b1 V
imp.fit domain name is for sale. Inquire now.(x)+ P; e4 p; `; x
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])2 @( @6 ?" Y. T. p6 H$ z
imp.transform(x_test) ( l- q1 F$ @/ W; V! \* Z0 N
当我们拿到一批原始的数据
0 k" d& _ m/ m' s" F2 o 首先要明确有多少特征,哪些是连续的,哪些是类别的。 # W7 H M0 M3 S. s. o7 ~$ }; B
检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。 9 p' h7 J8 a* I5 M. l
对连续的数值型特征进行标准化,使得均值为0,方差为1。 : L% I: r7 r" e9 U' {% j; D
对类别型的特征进行one-hot编码。
7 E3 }$ i/ w: Y H: y) \ 将需要转换成类别型数据的连续型数据进行二值化。
( ~6 X) `8 x% t3 p" n# Z% `. T k 为防止过拟合或者其他原因,选择是否要将数据进行正则化。 6 k3 `/ E k7 [* @+ {0 Q# M2 ^
在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。 3 S" O# v4 z8 ~% A& A; e
根据实际问题分析是否需要对特征进行相应的函数转换。
$ A4 ^1 }$ A) J5 L9 s 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 2 @5 I3 U/ G1 g) L6 A
因此针对动态的数据可以采用如下几种计算方法:
( j7 V# Z+ u7 Y. J2 e- Q1 v 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客
, W3 A; X- b# _6 F7 @( ]+ L. d
1 I" ]+ I, `$ z( O' D* Z* a2 e$ H" W# w1 ` {+ q* @0 n1 b
; C2 u, J3 j- X7 Q! t/ K" w& x( Z( [& ~7 x" l' V7 L! T: @, A
|