sklearn Preprocessing 数据预处理

[复制链接]
2 k/ L |& w1 G) S

sklearn Preprocessing 模块

对数据进行预处理的优点之一就是能够让模型尽快收敛.

标准化和归一化:

# L. R+ }9 @! ]' Z8 t+ f

归一化是标准化的一种方式,

$ S- \$ E( k* w6 X- u8 L# M

归一化是将数据映射到[0,1]这个区间中,

/ _0 p0 M5 E H6 f1 Q/ p( N

标准化是将数据按照比例缩放,使之放到一个特定区间中,

& B. B, ?: T4 }: m0 L% |! i

标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.

, A: z( Q) c8 a! q7 J% d, M

如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)

I" d) L8 K( }; ~ v; y7 [

导入模块:

6 p+ q* Y) r. | h, A R
from sklearn.preprocessing import StandardScaler t5 @' n9 ]0 W3 m m from sklearn.preprocessing import MinMaxScaler T3 o' [+ W& }0 Y) ]/ m from matplotlib improt gridspec 4 P" |/ k9 n: n% d0 k3 W/ E9 W0 y import numpy as np- \/ ?$ W0 b" k6 X' V* r import matpotlib.pyplot as plt
4 X; R) g8 M# a, P9 e* n* M- d

使用sklearn 进行标准化和标准化还原

# n9 P" W! L. o' Y5 f. n' C6 T% V4 C

标准化的过程分为两步:

去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的

x_scale = preprocessing.scale(x)

^ A& B9 j9 B1 X/ N
std = StandardScaler()) U; O% q' x! z6 p$ F data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])' L) k" ^3 D9 e6 u; [- a [; T9 h4 j, }; R) B. G. i9 U { # 将标准化后的数据转换为原始数据。1 Q% S9 c6 ?/ U+ C5 }. n std.inverse_transform()
8 }" [1 j1 H5 N) Q9 ?: A" g

查看标准化后的数据的均值与方差

; ~: F4 N) B. D0 n
x_scale.mean(axis=0)# 均值
" O6 ]; i3 u2 r

# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作

1 Q4 x" _7 [) `8 U; }9 C+ `
x_scale.mean(axis=1)
% s2 n1 w S9 n. A* w% E

`

& m& h; d9 R$ t3 K* z$ F
cps = np.random.random_integers(0, 100, (100, 2))* a, J; ]6 c9 O6 \ # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集. : h' |" G( B* R' d) r" m t- q ss = StandardScaler(); c5 `! z. n7 o7 J& c std_cps = ss.fit_transform(cps) + P8 Q. Y9 N4 b gs = gridspec.GridSpec(5,5) % w+ X+ Y/ _" ~ fig = plt.figure()# H" e0 u9 P; T( k' c ax1 = fig.add_subplot(gs[0:2, 1:4]) 3 B1 @* G) P4 x' p# |; G ax2 = fig.add_subplot(gs[3:5, 1:4])* ?# c- ^+ ], d* ~2 A. u1 ?6 r5 G& O# m ax1.scatter(cps[:, 0], cps[:, 1])7 g! q$ v/ ]1 r+ v3 z# ^ ax2.scatter(std_cps[:, 0], std_cps[:, 1]) + x2 f, G( {/ K plt.show()
3 J5 U3 _4 {( `! x3 J

`

5 F+ g* G! b& Z& m' O- ]
from sklearn.preprocessing import StandardScaler) F: S/ r( H- ]- y from sklearn.preprocessing import MinMaxScaler7 q3 n% n t( g" K: ^1 o8 e from matplotlib import gridspec 5 `0 d5 k/ f# }0 a& H/ ^# i9 {) X import numpy as np 6 T; v8 D) ?0 {0 G import matplotlib.pyplot as plt" v, w) @- B% p7 |5 H" \! a7 y data = np.random.uniform(0, 100, 10)[:, np.newaxis] 1 a- b I: t' u( C/ c' K% d2 O ss = StandardScaler()! E, v& h0 z8 D std_data = ss.fit_transform(data)7 W7 Z X. K6 E& l2 K; \# B. Y: i origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据: p$ R: p/ p1 c! t print(data is 原始数据,data) 6 p/ W4 ~# x" f3 X4 } print(after standard 标准化后的数据,std_data)' G- i6 C4 h( r. x& N# z print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data) 9 h$ F" X+ L( R2 o9 ]# g print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
, P- u. b! u* t2 w9 K0 ?7 c

使用sklearn 进行数据的归一化和归一化还原.

. I% `7 g4 Y9 b1 U6 ]4 G+ B1 {
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据 & U$ W; W( ~ {* V% T6 e mm = MinMaxScaler()# 创建MinMaxScaler 对象 + `7 G& k& T/ m( ?+ u$ R* q) C mm_data = mm.fit_transform(data) # 归一化数据1 D$ m: u* @4 S' a5 w6 Z origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据) |- O* D( _2 G* V- J/ i3 v print(data is ,data) {, K0 L$ ?% w' E' l" _. ?$ w print(after Min Max ,mm_data) 1 W! U6 J3 s" Y/ ^8 f \ print(origin data is ,origin_data)
! g% j$ M; D6 }9 @6 D9 u

MinMaxScaler和MaxAbsCaler:

' F& t# `/ K0 W1 O$ V

MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)

7 [& | J2 }6 Y7 y9 y5 j

MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间

; \2 `. Z& F/ s$ U3 z. g+ M
min_max_scaler = preprocessing.MinMaxScaler() V+ l9 g! l0 J, o3 T( v, u x_minmax = min_max_scaler.fit_transform(x) % l. y+ p% r3 Y# g x_minmax
6 k7 V* t: k5 @: M; c6 j% o; H

对于新进来的数据,采用如下方式进行函数调用:

8 Z% K2 A r' K" e9 o" r4 R: P
x_test = np.array([[-3., -1., 4.]]) 7 ]; y) y* h( C3 O8 g0 _* w x_test_minmax = min_max_scaler.transform(x_test) 6 B' o4 D* ^" K x_test_minmax
7 M2 u9 v/ x! S1 @/ k

MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.

" r e* q0 e# H* O7 T1 \
max_abs_scaler = preprocessing.MaxAbsScaler() % n3 {9 d" {& |0 ^# w% G9 `, \ x_train_maxsbs = max_abs_scaler.fit_transform(x)3 P. N9 E& M9 a8 S5 t( o x_train_maxsbs
6 {4 Z7 I/ f4 G0 W* E C4 B

# 同理,也可以对新的数据集进行同样的转换

# _( k, C9 d0 I1 M- {+ T
x_test = np.array([[-3., -1., 4.]])2 I, E2 x# U, u x_test_maxabs = max_abs_scaler.transform(x_test) $ F5 `, k8 {5 d/ a+ m& } x_test_maxabs
* e& h( `9 ^1 ?3 }+ `: a

针对规模化稀疏数据

6 ~. m: Z2 ~* y8 Y9 T0 c! h

对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:

3 B; Z, ~9 Y! \# L1 Q

MaxAbsScaler,和maxabs_scale

) n9 V0 h; Y* Z: X1 f' ]) u# W

针对规模化有异常的数据

7 o# J1 o8 N! N

数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.

* i4 O" \$ b& q5 l3 W

正则化Normalization

: g3 q2 J7 t! L, q( v! L3 d

正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等

5 @+ C: j9 ^- ]$ C& }/ _+ R
x_normalized = preprocessing.normalize(x, norm=l2) % T! S. G4 v) N7 T7 e3 } print x4 P7 S7 l$ s- J! [7 [ print x_normalized
0 `" j7 H4 B4 |* ^# u% d% Q- X

# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)

/ G% o/ Y U" _9 ^ w- G' Y
normalizer = preprocessing.Normalizer().fit(x)/ Z! f4 I3 i. a normalizer
2 E9 ^" [# P+ _) C4 b$ L; b- j. W

# 对训练数据进行正则

, A4 Y/ P7 P7 y
normalizer.transform(x)
$ S/ C' h0 m; g2 A: J

# 对新的测试数据进行正则

2 m. ~) Y, S4 W, P
normalizer.transform([[-1., 1., 0.]])
* R5 ^! C& E- q* v$ j

二值化

( i0 {8 `+ Q+ N E0 i3 _! @( D

特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值

5 g$ }: Y1 E: Q0 d M* j
from sklearn import preprocessing. e' Z$ E* m. ?1 Z- | import numpy as np 6 O* C9 C$ c1 m; ?5 d* `; a% s+ k( y' u. M4 S # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征 " Q- R4 P& T J! r- d% m5 b x = np.array([[1., -1., 2.],. r2 o" b( L1 z [2., 0., 0.],. Q7 V+ Q1 ^" `. ^ a" P [0., 1., -1.]])7 M" h4 z* K1 W4 ? # D$ B# B/ R. U% f5 I, v8 \ binarizer = preprocessing.Binarizer().fit(x)7 n( o9 k; E# Q% h" k6 M5 x/ O2 ^. w9 e- A binarizer.transform(x)3 q6 K: P! o7 r/ ?% y: g( ?" ` B3 P; a. i3 g binarizer = preprocessing.Binarizer(threshold=1.5): l) y; Y( E% g- y# W binarizer.transform(x)
' l& G+ J' k) Z

为类别特征编码

+ L( {7 V3 @' m% Q% \

(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.

# l( b" ]8 Y: f" }

OneHotEncoder

+ h2 S# L0 D! K& g

弥补缺失数据

4 i" S( o9 }7 b* h

可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.

a A2 ]3 H5 o8 O' f8 s; Y
import numpy as np& h, W) Y: e$ r# y. \# c from sklearn.preprocessing import Imputer * Y: k2 `- P) `, \. i7 G l; h imp = Imputer(missing_values=NaN, strategy=mean, axis=0)7 V! b; t. Z$ Q7 C& [. Z/ O imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])9 ^% O: H E" D, ~1 I( Z5 ?3 j* D, A5 } x = [[np.nan, 2], [6, np.nan], [7, 6]]# A m# s9 N9 l* x6 ^ imp.transform(x)
3 @6 N# V$ A, U

Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值

4 I3 b, Q- U) k& o3 u. o0 @2 _
import scipy.sparse as sp, X' |3 `8 e R8 [+ a: n! F2 s # 创建一个稀疏矩阵1 ]6 m4 F- g' ~ x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])/ J# H9 L: T8 E. u1 X imp = Imputer(missing_values=0, strategy=mean, verbose=0) , ^5 O: U# `+ q7 m8 B imp.fit domain name is for sale. Inquire now.(x) @/ `5 m& f! a+ g$ w, Z3 h- Z x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]) , l8 S. b( A; w7 J5 e3 t4 j imp.transform(x_test)
8 W" |# ^5 y8 d' a3 G& ]$ @! f' G+ R

当我们拿到一批原始的数据

6 j) l" X ], ^5 s/ Q

首先要明确有多少特征,哪些是连续的,哪些是类别的。

& X+ `( [/ }/ F) ]: N

检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。

- s. I) C% ^5 G. |

对连续的数值型特征进行标准化,使得均值为0,方差为1。

; j- M7 e/ o/ u ^; ~ B

对类别型的特征进行one-hot编码。

. P2 B: r: ^; L# @# |

将需要转换成类别型数据的连续型数据进行二值化。

9 o; p( U; @: `9 w

为防止过拟合或者其他原因,选择是否要将数据进行正则化。

6 E! y% l: u# W( s) t2 r+ j

在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。

) k' [8 j8 O! @% }/ |& ]" j7 F' W( }

根据实际问题分析是否需要对特征进行相应的函数转换。

5 J/ K# c' f! z! O& J

标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点

) c/ @9 J) {' @4 g0 e! m' ~

因此针对动态的数据可以采用如下几种计算方法:

' v0 S! e# h5 {( l! j1 W. V

1.arctan反正切函数标准化.

http://2.in函数标准化

预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客

2 s3 T$ w1 a+ u: u* o 1 D$ G$ B9 [2 G# b4 ?0 O U' E% i& [& ?7 `* X ( u* T3 ?2 N* Q9 z* T t0 I9 D2 \ 0 E7 ~* D# K2 z/ O1 ]- w
回复

举报 使用道具

相关帖子

全部回帖
暂无回帖,快来参与回复吧
懒得打字?点击右侧快捷回复 【吾爱海洋论坛发文有奖】
您需要登录后才可以回帖 登录 | 立即注册
天阶雨
活跃在5 天前
快速回复 返回顶部 返回列表