|
, F) P. Z, `' [5 z% k$ m+ @ sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: # k4 g# @5 h2 w) v" R) n
归一化是标准化的一种方式, . W( R: i+ T g9 y
归一化是将数据映射到[0,1]这个区间中,
% o! m0 u& z4 O0 ]2 v; u2 _, l3 ` c7 ` 标准化是将数据按照比例缩放,使之放到一个特定区间中,
% X- A$ q/ r. x. } 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
! u+ T! E5 ?; |- b+ U: o 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) 1 L1 ]& m. ?* S& d6 k$ A
导入模块: 8 E+ {- w4 c- ?4 F I) `
from sklearn.preprocessing import StandardScaler0 `% W, Y; E: _
from sklearn.preprocessing import MinMaxScaler7 a/ q2 n3 j: j G
from matplotlib improt gridspec% H* p1 Q3 T" J. C/ l) y
import numpy as np
1 A: U v# ?, v! N! d: E) ~ import matpotlib.pyplot as plt
: Z# i0 G \9 g! H 使用sklearn 进行标准化和标准化还原
9 ~- L: n; h& i* O- i) U 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
$ D7 C0 K" T, |5 K- l std = StandardScaler(): Z# v4 P# O' Y5 ?* o: |
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])% _% L, x/ W8 e7 [
4 p+ S2 B- I3 J9 R1 m, n$ w6 D1 j
# 将标准化后的数据转换为原始数据。
5 v7 E1 }8 Q' ^+ t std.inverse_transform() # P$ C) x6 Z+ a7 z5 O
查看标准化后的数据的均值与方差
1 {1 E2 ]: [4 n" n; [ x_scale.mean(axis=0)# 均值
, h& j- b7 [& H # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
" u L3 I5 H1 v( K0 _ a9 ^ x_scale.mean(axis=1)
" G" `& G3 q/ \% }( K- c4 q ` ; i. D U0 ]4 P/ C
cps = np.random.random_integers(0, 100, (100, 2)). e' T4 I. k% N2 m4 x' S8 }% R
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
# J, R' Q* K6 a2 E$ d6 r ss = StandardScaler()" s3 o. A: c- w! I
std_cps = ss.fit_transform(cps)) @& g: ~/ B1 {' ~0 _
gs = gridspec.GridSpec(5,5)
% Y) F! y3 u# v# O5 V: ^2 i, } fig = plt.figure()7 I& n6 O! t9 b
ax1 = fig.add_subplot(gs[0:2, 1:4])8 G9 K8 H8 I2 q( K
ax2 = fig.add_subplot(gs[3:5, 1:4])
6 [* V4 `& p' z0 X3 ~8 w ax1.scatter(cps[:, 0], cps[:, 1])5 r1 f" t' y: q' ^% ?, m' a( h
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
6 r' C# q: w7 P7 S% Q plt.show()
$ L7 i7 f; R5 B `
0 n9 I/ C }! K) H7 ^9 u4 A from sklearn.preprocessing import StandardScaler# C0 M/ O2 R4 m7 ]
from sklearn.preprocessing import MinMaxScaler9 S$ H7 ^' S1 s# i
from matplotlib import gridspec; e3 p, H% x( W6 a% |+ M8 q
import numpy as np* c+ C( P0 x1 }! b
import matplotlib.pyplot as plt
5 D- {* s. |# k% n data = np.random.uniform(0, 100, 10)[:, np.newaxis]
+ k( K1 b4 h' t+ Y: j1 G ss = StandardScaler()5 b C2 B3 \& @- q1 Z& V) v
std_data = ss.fit_transform(data)
: L0 r4 N5 I( @. Z e origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
. \' {; c" h2 K1 h/ X" U { print(data is 原始数据,data)
* T" x: Z' F$ M$ n- [7 Q/ \7 r A print(after standard 标准化后的数据,std_data)' \$ b5 W1 m4 i+ u
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)! b4 ]$ Q. r3 C7 {: C0 a
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) % l3 R$ }: O4 G6 B$ a" ]+ q
使用sklearn 进行数据的归一化和归一化还原.4 v! L+ T) U4 S& _& m
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
7 y' h% h! T3 O% }9 O: W$ f mm = MinMaxScaler()# 创建MinMaxScaler 对象1 M5 ~3 e$ l5 W
mm_data = mm.fit_transform(data) # 归一化数据' g. f+ D8 w/ w! @6 Z1 e! m
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据4 w- u4 @6 g# w, x1 `2 ]
print(data is ,data)4 v- D6 J- Q2 o2 }0 y' Z
print(after Min Max ,mm_data)
5 [' C0 ?7 S, M1 W3 X print(origin data is ,origin_data)
$ g+ h; {0 L* [ MinMaxScaler和MaxAbsCaler:
8 c/ \- c: R( m. m( ~0 m MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) 9 v0 {/ R. g1 j
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
2 p1 h3 r- |' }' c0 S min_max_scaler = preprocessing.MinMaxScaler()
( ?5 ^* u2 O% E% A/ Q( e; [ x_minmax = min_max_scaler.fit_transform(x)/ ~; s: d" x1 x( D- I( [2 _
x_minmax % I) c) X; W( h( x) R- `; }& C
对于新进来的数据,采用如下方式进行函数调用:
7 x" C- n7 ^$ L* k# P" T x_test = np.array([[-3., -1., 4.]])( N" o |3 H. G* H8 }
x_test_minmax = min_max_scaler.transform(x_test)
[1 H7 @7 w3 @( N3 b ]+ h( p x_test_minmax ' d$ {( [3 S% s+ }
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. ; O4 [9 C! {% T5 Y
max_abs_scaler = preprocessing.MaxAbsScaler()( P: e4 D y8 d3 a" y D. m# z
x_train_maxsbs = max_abs_scaler.fit_transform(x)# N% s4 U7 C' S
x_train_maxsbs
8 O6 i$ u" O1 N6 ]* y* f7 ]0 b- P # 同理，也可以对新的数据集进行同样的转换
9 o( Z6 C8 c! @. d5 c% g x_test = np.array([[-3., -1., 4.]])
; [) N/ v/ I E" Y: z, Q; l x_test_maxabs = max_abs_scaler.transform(x_test)
7 E$ n6 X# X/ S" [% @ x_test_maxabs / H( L/ u# U$ ~
针对规模化稀疏数据, g' _2 r( K' [) u+ Y J9 ^+ W
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
" h# b& r; v+ ? MaxAbsScaler,和maxabs_scale ; g0 J& q4 U% h5 E4 q
针对规模化有异常的数据* `8 e# {3 y' g1 r
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
6 A) ^! m) I* h( Y) L6 Q8 F, U: ^$ m 正则化Normalization
+ Z. f/ }% [, z/ L7 F6 y5 B) E 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 2 K$ V: R: d6 G. d e
x_normalized = preprocessing.normalize(x, norm=l2)/ O8 B* m1 A$ i# |! d
print x
7 O6 B# C& i( K) J* L, ^5 H, p print x_normalized
' G6 U% w, x# [* ?0 B6 Z # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) # [" E. N f$ M# {
normalizer = preprocessing.Normalizer().fit(x)
. C3 R, y5 B, X/ T6 t& A; V8 A7 p normalizer
7 k& w4 g- F. b' A # 对训练数据进行正则 $ R x) k4 U! }4 U; s
normalizer.transform(x) 2 m# i Z W; G) w8 R
# 对新的测试数据进行正则
5 c: n: N2 ]7 G8 P normalizer.transform([[-1., 1., 0.]]) / g# o4 i7 a! {3 [
二值化( }. z4 Q% F) Q& Z0 U* h, d
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 3 o* d, x0 R# j7 N0 Q* |
from sklearn import preprocessing: _) H- v% D3 X q$ p
import numpy as np
6 j% t' Q1 A) {& K/ F, Y( u; L* P# N, \
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征/ \% J2 g3 }/ K) c q% e! ]
x = np.array([[1., -1., 2.],7 b7 O8 ?$ j) s/ U7 f! b
[2., 0., 0.],
7 Q/ H" ?9 C6 z+ B0 l1 t' D: e [0., 1., -1.]])
. C3 R, u) B! y$ W: r" S+ y' \3 @) I
binarizer = preprocessing.Binarizer().fit(x); a& w. y: D; `. b+ p
binarizer.transform(x)$ }% a" c- W7 [* z
, j5 y/ C( O+ q- b+ |
binarizer = preprocessing.Binarizer(threshold=1.5)8 c/ w% u1 _/ i- x1 v
binarizer.transform(x) 0 H5 X" f5 e$ _ i
为类别特征编码) y9 y; ^, b% ^3 }9 u; l; V3 l/ O. i
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. . r4 T: I! M2 x6 {7 N: f
OneHotEncoder . A8 t4 q- F) v6 i& h
弥补缺失数据
0 h2 O+ w* p0 u: c2 g* D0 | 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
8 \- }! a! U6 O: e import numpy as np
: p- m4 x% z" i$ ^0 D) e" | from sklearn.preprocessing import Imputer
l) l3 p5 ?2 f/ e) Y/ K, X imp = Imputer(missing_values=NaN, strategy=mean, axis=0)9 S" p; n8 `3 x( M
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])) l% A: R$ }& z- ~& a+ f# [& u
x = [[np.nan, 2], [6, np.nan], [7, 6]]
. g0 r! t2 N0 i imp.transform(x)
/ W& e5 v+ o6 b+ t7 p& W Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 " W6 {- V/ g/ k- Y9 Q- e! D) U
import scipy.sparse as sp
+ W7 n+ n' g+ @0 O3 I, t' _ # 创建一个稀疏矩阵: ]0 W+ ?4 d r& ]8 w% Y" G& p
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]]). `3 V/ L3 P8 I6 i. O7 p' c
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
i2 a$ C- E4 D% m8 l" }, l) u; Z l imp.fit domain name is for sale. Inquire now.(x)
5 O( Z# N+ r5 y, }2 V$ R* k x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
" k* G( ^& o4 y7 H* i imp.transform(x_test) Y. e @9 |. |
当我们拿到一批原始的数据
# J# E! z) P7 O: Y7 R; _ 首先要明确有多少特征，哪些是连续的，哪些是类别的。
! w9 | U4 B/ l/ V8 D+ u 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
# o" x* y4 W4 h2 J0 J 对连续的数值型特征进行标准化，使得均值为0，方差为1。
5 t3 |: ~5 f, H- o8 C 对类别型的特征进行one-hot编码。 5 c5 r6 `2 A( m( ~0 I
将需要转换成类别型数据的连续型数据进行二值化。 3 Z+ N; a# U! }4 ]! F
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 6 r( F$ G6 [ C# s! G) W# n% ?* C
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 / S: E8 O: q+ M$ }, v& s+ |
根据实际问题分析是否需要对特征进行相应的函数转换。
8 K0 {2 s6 L( s B0 p9 w 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
1 k( W o, [; F( x2 d G6 J 因此针对动态的数据可以采用如下几种计算方法: N" H* T7 h6 V# h0 v+ \
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
8 i) L; c# r. p7 ~1 `% n' w: k: l. D- w- k
" n& H4 F' u2 s/ G# O5 a3 z- e) p/ s
! Q8 t6 |. j4 p. p; {- z
| 
