|
" t' O& |+ X: I* E( o
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
. C v& m8 k$ M' R& f3 `8 d 归一化是标准化的一种方式, q7 K/ f% g/ l$ \, ^
归一化是将数据映射到[0,1]这个区间中,
: u! z' z( r1 k; [7 ^ 标准化是将数据按照比例缩放,使之放到一个特定区间中, - w t% z* j) A1 P9 l: L
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
! q5 j" M; x& h# S4 j 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) 3 ]3 g. v2 c% R4 R8 h1 \
导入模块: " g# C& I7 I( Y. w& D+ s7 H
from sklearn.preprocessing import StandardScaler) T; R2 t' P& V9 c/ ]
from sklearn.preprocessing import MinMaxScaler0 i' b b3 D- {7 s' S- M
from matplotlib improt gridspec1 G: E3 E8 z2 b: z; M
import numpy as np0 u( X) q1 n" J
import matpotlib.pyplot as plt : O1 P- Y) V& I+ z* ^! b1 d2 D
使用sklearn 进行标准化和标准化还原7 U- {" C7 C# g& G# |4 L
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
7 g) E+ b2 i8 s! `; g" L+ L std = StandardScaler()+ K4 p1 p6 {4 h
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
; B( ]7 u( d! s2 E% M9 r
/ Z/ I5 ?0 Z% \1 g # 将标准化后的数据转换为原始数据。! t7 J/ b0 {- u; w( {; U
std.inverse_transform()
+ C8 x5 ~- I) h7 u# P" J) }8 ^ 查看标准化后的数据的均值与方差
7 f% P5 u4 R9 V x_scale.mean(axis=0)# 均值 ! P1 v1 e" k! K! g( v) D1 `
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 ) J! ~0 m# s" x5 |4 ]3 {) ]- F
x_scale.mean(axis=1) 1 E8 d1 @; q) w0 [" G2 w' G0 A
` / W* [8 N' { x$ _5 g4 M7 P
cps = np.random.random_integers(0, 100, (100, 2))
! t3 a: z. C$ B" r' k( b# j) F. O8 j # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.! ~) B4 }+ Z7 Q0 B- K' K* @3 M
ss = StandardScaler()
1 k# M, b) {( h7 N9 M7 D std_cps = ss.fit_transform(cps)
' ?( q4 ^1 H1 X/ l6 F3 F2 ]5 Q/ K gs = gridspec.GridSpec(5,5)* ]) b0 X( Z4 P8 W
fig = plt.figure()
8 h- u6 g6 z$ a3 y ax1 = fig.add_subplot(gs[0:2, 1:4])
" ^0 A: @+ m# [7 X8 Q/ o ax2 = fig.add_subplot(gs[3:5, 1:4])0 \1 u. U* h7 W: z" u# \
ax1.scatter(cps[:, 0], cps[:, 1])3 [; H6 `7 `8 T5 C
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
4 a' j5 Q S" h plt.show() 5 i _4 ] V( V, S! [
`
% e& j9 k9 i5 h9 _7 o3 j from sklearn.preprocessing import StandardScaler
+ {; K+ D- o/ W& g from sklearn.preprocessing import MinMaxScaler
1 }0 T- i6 O1 K7 ? from matplotlib import gridspec
$ @) Y. \6 Y6 b, J import numpy as np3 F5 z9 B8 B3 y7 v1 g; N# v! L
import matplotlib.pyplot as plt% F5 c) K2 X# ~, ]3 S5 _' @1 S
data = np.random.uniform(0, 100, 10)[:, np.newaxis]% D. W- M8 A, o1 {: g
ss = StandardScaler()+ }7 ]" F& Y* U" d
std_data = ss.fit_transform(data)
# p5 l: F# x9 D$ `0 x* M* k origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
7 a$ n( g6 i$ z& y7 X5 P. Y W) v print(data is 原始数据,data)
9 _9 v1 E8 k! J& e9 `# N) o' c5 O& ? print(after standard 标准化后的数据,std_data)6 y4 \# g S) d9 [' j! B1 e
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)
4 i( Y! J: Q6 v/ k+ | print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
' }* T0 N1 G! l k5 d6 J 使用sklearn 进行数据的归一化和归一化还原.2 E2 y+ V8 ~; {% o7 N/ Y& d b; e
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据! Y1 a, b, G3 u5 \: A# H
mm = MinMaxScaler()# 创建MinMaxScaler 对象' v6 O$ A: L5 x* {$ p, a9 e. y
mm_data = mm.fit_transform(data) # 归一化数据3 N; ^- S& m- F8 M( p1 N( q' q
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据' v' J. \- O% E/ i& i
print(data is ,data)8 L0 X# r1 \" [* h4 k0 M" p
print(after Min Max ,mm_data)
( Z+ X. M9 W, t print(origin data is ,origin_data) * N Y# L) X. \
MinMaxScaler和MaxAbsCaler:
0 w/ W8 u2 y. P( B7 V MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
. |8 T: b P9 Q7 B5 r MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 , n0 @& x: ~, g' d# I1 h* z. r" l
min_max_scaler = preprocessing.MinMaxScaler()
$ p1 Y9 B P9 F6 M3 v% x x_minmax = min_max_scaler.fit_transform(x)9 z: h- A1 @& ]
x_minmax
7 W& t+ E3 Y( b9 ` 对于新进来的数据,采用如下方式进行函数调用:
, b* ]. Y9 q8 R* _& i( x x_test = np.array([[-3., -1., 4.]])5 A2 V* ]- ^$ Q6 M9 w: M) D6 t
x_test_minmax = min_max_scaler.transform(x_test)
' f M( r+ z2 d x x_test_minmax , C* n# h* A5 V! `3 X$ {
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
5 d% ~; L- @2 \' K( j. O& E3 ~2 I max_abs_scaler = preprocessing.MaxAbsScaler()
* i+ }3 \: K9 Z) |2 m x_train_maxsbs = max_abs_scaler.fit_transform(x)
, e) i9 U4 ?+ U0 e x_train_maxsbs ' _% n# H2 @. M. t v' a- e* `
# 同理，也可以对新的数据集进行同样的转换 & b( _6 d8 b+ |8 w
x_test = np.array([[-3., -1., 4.]])
^* O7 ]( m2 f3 |# }- X x_test_maxabs = max_abs_scaler.transform(x_test), o3 D4 ~, V( M9 x
x_test_maxabs
) Q1 X. j8 c+ s! e* x7 W 针对规模化稀疏数据
5 P- E4 L, }8 T 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: 7 O2 L% Z+ q7 C5 t- l
MaxAbsScaler,和maxabs_scale : r; S& `7 r5 X. P4 E9 S
针对规模化有异常的数据
% {! l1 ]# j7 L0 Q! Z* e; c 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. " W. \" p0 i4 Q) J2 u# z' t
正则化Normalization
3 y+ }, X7 y! @ u 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 ( r }( l7 I5 v" N. n
x_normalized = preprocessing.normalize(x, norm=l2)
/ \0 r* M2 u' F1 r9 s- E print x% N% i5 I! H- |+ |. n
print x_normalized
$ m6 h3 U! t# T/ j# h # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
2 J* F4 W- R2 F$ V/ k# E normalizer = preprocessing.Normalizer().fit(x)) c3 `& b4 R& e! j) e
normalizer 3 K% G7 O( N& d
# 对训练数据进行正则
6 t3 m' x$ L$ D! \ j3 D& X( [. H% R9 z normalizer.transform(x) 3 M+ g+ ^5 H6 f9 X
# 对新的测试数据进行正则
! \& [6 z; W% R. U6 D- A6 T normalizer.transform([[-1., 1., 0.]])
0 ?5 K! c5 w. J* w/ N; E5 M7 Q, t 二值化2 O8 O# q! {6 i9 ~ U
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
, T* C* E/ v8 ?; J! v0 [' M from sklearn import preprocessing
0 { z9 |2 b, P5 \% D4 M4 s& f import numpy as np7 x" r# V f; l/ h( }/ E
- B' x" ~* Z3 L+ ^
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
5 x% f$ Z3 E9 q7 H s* @ x = np.array([[1., -1., 2.],3 x& @' i# u" H' }9 R
[2., 0., 0.],
0 L6 L3 |- V2 [5 i& y [0., 1., -1.]])2 m0 f9 _$ V% ]' S7 O% N& m
% n4 @, v4 a5 r! H; d8 G# O
binarizer = preprocessing.Binarizer().fit(x)
1 \5 S3 v+ X+ ~7 l6 b: W; K binarizer.transform(x)
! s9 E& Y4 R1 b# f2 |! P
6 n& V' M2 `5 Y$ _6 t binarizer = preprocessing.Binarizer(threshold=1.5)# s- H# l4 ~" P2 B
binarizer.transform(x)
7 G2 V, O$ y( o5 _, X 为类别特征编码
& } m+ x% a5 e; W S0 M; W! g (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. ) ?) c8 u! |# b4 t. }
OneHotEncoder
) |) M% e' o U6 s. i 弥补缺失数据
* w: d0 x7 G$ h0 p) L 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 4 ~& b. i- D) X: `
import numpy as np r# i) _2 X. W' K
from sklearn.preprocessing import Imputer2 U! `7 @2 ~' G" u; P* t8 ]
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
8 Q$ M! W# @1 T9 O9 A! [ imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
+ j B) A% ?' a( h1 o x = [[np.nan, 2], [6, np.nan], [7, 6]]) Q7 _1 ^& U L9 r, O8 X
imp.transform(x)
3 T! _+ C# d, A: T) y8 C- P Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 , v. n( N6 q+ I
import scipy.sparse as sp" C: t* C" U+ R- b. E8 Q
# 创建一个稀疏矩阵
( z' h8 _; v& y6 V4 G$ ? x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])0 H: l3 q! @& [0 G6 W) B
imp = Imputer(missing_values=0, strategy=mean, verbose=0)* v$ C+ }: v& Z
imp.fit domain name is for sale. Inquire now.(x)" T: H$ w8 [1 P( O
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])7 D% b) K& F% c# q
imp.transform(x_test) $ d9 l9 o4 Q5 Y5 X& G* K
当我们拿到一批原始的数据 ) `8 h+ z: U. V6 I6 P
首先要明确有多少特征，哪些是连续的，哪些是类别的。 ; Q8 L, M# E! ]* v' G: `5 a# g
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 - H: ^& O! @# W; O# S' C; _5 }
对连续的数值型特征进行标准化，使得均值为0，方差为1。 & y; l' x, l, j/ d& p4 N5 l
对类别型的特征进行one-hot编码。 # I2 l% ]% \* p( g% D' o
将需要转换成类别型数据的连续型数据进行二值化。
$ v2 a% i3 c0 Q3 I/ j- w# M% u( s 为防止过拟合或者其他原因，选择是否要将数据进行正则化。 ' @+ O3 {1 j$ g: C, S
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 & u4 ?0 P2 z) a2 Q5 D0 _; ^9 S1 f
根据实际问题分析是否需要对特征进行相应的函数转换。
% T# |) V& z( J. H 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 5 Q' a: s. b0 q# O# @% o/ m
因此针对动态的数据可以采用如下几种计算方法: & K: n2 a+ D% f- ?
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
M2 m7 ]- l* E, i+ i5 r1 j( s- t/ R
2 o8 C/ f& C* @& J3 b0 I# j0 Z/ F! t/ M
( C/ b: g u! x. Z0 f9 G3 T h+ L7 O1 ]4 _- `6 S2 `/ V
| 
