sklearn Preprocessing 数据预处理

[复制链接]
6 a# `5 s% [1 |" G3 X( `

sklearn Preprocessing 模块

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

标准化和归一化:

+ p& o* P" S0 B# v5 v4 ?

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

% @6 i( s3 |! s$ t' o

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

- A- F. h9 i7 v' a

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

4 j/ J% [$ ~* j1 J" F3 L

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

# x% j0 K) p1 x( k5 U3 x4 ~3 P

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

% w/ G0 R/ ~" B7 j

导入模块:

0 m( ?. N2 K( x
from sklearn.preprocessing import StandardScaler, f1 G8 O4 ]- V: Y" F' C; J* i from sklearn.preprocessing import MinMaxScaler % i, v% W- B( l+ a from matplotlib improt gridspec: H' }' @% }0 v* A9 y6 Y* F. @ import numpy as np5 T3 J7 M& G8 b$ Q import matpotlib.pyplot as plt
, T8 B9 b) i+ t, e( H4 y; h

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

. k7 C8 {: K4 B1 X% T% _' N

标准化的过程分为两步:

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

x_scale = preprocessing.scale(x)

: L g0 d- J; D3 J8 W; o+ g3 P
std = StandardScaler() L% D8 W/ B' S) X8 Q) k data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]) 1 x6 R7 H2 u) Q8 W. t1 Q( |0 L/ K0 ~1 k- L' E% I1 s% T- w # 将标准化后的数据转换为原始数据。3 b }9 h$ i3 A/ E2 C& E \7 R i. i std.inverse_transform()
* H% o' y& C- j/ G

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

' }1 M" t2 @8 D* |: M$ t/ c* l4 U* C
x_scale.mean(axis=0)# 均值
$ ^, `8 P8 W3 {. ^" f4 ^

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

- A8 J/ t& A" r1 E
x_scale.mean(axis=1)
1 Z7 ~, q `/ `& Z. [# w

`

# ]" `+ \! |8 W7 j0 {
cps = np.random.random_integers(0, 100, (100, 2)) 0 m$ x* p% h+ H+ F @( f" A0 B6 C # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集. ) W& Z* T. ^1 m" w+ K$ J% s5 Z ss = StandardScaler()) }) y+ I( e% |$ F" k std_cps = ss.fit_transform(cps) 6 D' F4 o, ^- S$ `/ y gs = gridspec.GridSpec(5,5)( d7 ?2 j' j: x' Y7 q. [7 I* T. @ fig = plt.figure() ! [' _& Z/ i1 V ax1 = fig.add_subplot(gs[0:2, 1:4])4 u- `3 x; H8 E5 C: X) r! g ax2 = fig.add_subplot(gs[3:5, 1:4]) : p( F+ Q; P- b9 T ax1.scatter(cps[:, 0], cps[:, 1]) 9 ~! o g) E' B0 N ax2.scatter(std_cps[:, 0], std_cps[:, 1]): }; k$ U) B+ K4 |& [( Y$ l4 K8 y/ P plt.show()
+ R: C! C; d& f: }+ Q" A% ^

`

* P4 f% t8 r8 i
from sklearn.preprocessing import StandardScaler & L/ `' N- K- S1 g, [( L from sklearn.preprocessing import MinMaxScaler4 ~: |" V( I3 \: e from matplotlib import gridspec ; N! }$ K; g* F$ g( p import numpy as np* V) r x( G3 N4 \5 I# I1 u import matplotlib.pyplot as plt" E* x" S. F( Q2 E I+ l data = np.random.uniform(0, 100, 10)[:, np.newaxis]) @6 B' l. n( k) D0 q$ B) H ss = StandardScaler() 3 ^9 _8 c8 j. ?* F std_data = ss.fit_transform(data) 1 Z* G3 r, _* E origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据 . w; ^4 b* w( p+ m print(data is 原始数据,data) . B2 D2 R4 Z# x$ J: } print(after standard 标准化后的数据,std_data) ) r. h1 t0 d5 H6 _7 v" R print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data) - L! w# N D0 l& P w print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
/ \; F) }! w* V, I0 t

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

" K6 l; g. N" Z# w# x. I b; F, \
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据% v7 l* r7 M' r9 W1 E" a mm = MinMaxScaler()# 创建MinMaxScaler 对象# p1 m9 r9 B7 @* C6 B$ B mm_data = mm.fit_transform(data) # 归一化数据$ ~" P1 ?7 v2 L origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据( e* K( H' Z: c+ @ print(data is ,data)0 ?/ K. I6 J! ^8 M print(after Min Max ,mm_data) d1 w) F( s+ K( e4 |$ T print(origin data is ,origin_data)
: E X7 A. U4 \5 A7 U- K

MinMaxScaler和MaxAbsCaler:

, F* l" i9 {! v1 C4 H/ B% c. ^/ k% y, E

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

1 v' m, b0 e3 {7 Y' {. P

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

+ j7 i, N# v |1 Z' o1 `: y# P
min_max_scaler = preprocessing.MinMaxScaler()* ^, m) u* f2 U* P' T) k9 D+ K x_minmax = min_max_scaler.fit_transform(x). ?) l: a0 o2 o5 ^3 l: M2 N; N2 ~' v x_minmax
) v2 S3 p( y8 l0 a

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

" _5 x8 N9 R9 T
x_test = np.array([[-3., -1., 4.]]) ( E" z5 F Z* j0 w: u x_test_minmax = min_max_scaler.transform(x_test) " r# Y) d( u9 c x_test_minmax
3 X) D3 t8 j6 J6 q1 c

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

) B; B9 B; R3 P! t4 Z. q0 c
max_abs_scaler = preprocessing.MaxAbsScaler() 7 ^6 L- s1 }, P2 ]6 Q' ]6 k5 v5 k, Q/ M x_train_maxsbs = max_abs_scaler.fit_transform(x)* R5 _9 l4 E6 T1 } x_train_maxsbs
4 e4 B5 J7 b0 ~7 a4 [

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

0 R# e1 x% w$ ]+ \
x_test = np.array([[-3., -1., 4.]]) z" [; h: ], I3 \ x_test_maxabs = max_abs_scaler.transform(x_test) ' M1 _& p4 N1 X: ?% W, E# P$ l x_test_maxabs
, ?; B6 K; e! {" j3 v

针对规模化稀疏数据

% o0 K& w* k% ~! S; _

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

! w0 W: Q/ Y3 D1 ?8 e

MaxAbsScaler,和maxabs_scale

0 x. {- P7 K% [9 F5 p7 w. Q/ K

针对规模化有异常的数据

8 X8 n2 a, X3 E( [- _

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

# r2 ?" ~- k- X* u

正则化Normalization

D' s. w, U1 ~$ ?% C

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

$ s6 {4 {9 I% {8 A( W0 q) i+ d0 ?
x_normalized = preprocessing.normalize(x, norm=l2)1 ^5 n4 Z0 M' q- _4 {0 \ print x& d, W$ `6 s! n! F print x_normalized
4 N6 a0 T. Z7 b+ L

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

+ s4 @! v- b; u5 U$ c/ ?% r
normalizer = preprocessing.Normalizer().fit(x): c1 Y# V- s* M! q r$ t+ r ^ normalizer
/ D+ D# d* W% q0 Q4 ~0 ?

# 对训练数据进行正则

( @8 ~; F" O) B' q1 X+ q) _
normalizer.transform(x)
/ @5 E* m- X& E6 w

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

4 F4 n6 W; h& }
normalizer.transform([[-1., 1., 0.]])
( r3 v5 ^' t9 Z( Z/ X: O+ ]: |

二值化

2 v5 C! a6 X" T; ^$ r! O' K$ B

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

0 \/ f& q) Y: z" c0 k
from sklearn import preprocessing $ B1 Q3 u1 e; Y+ e; h1 q5 I8 z& ]* F- V import numpy as np 6 i. o0 q: B3 a / M) d% k5 C: ?3 h0 ]( a k! D # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征, R" ?( r, X% [ x = np.array([[1., -1., 2.], 4 J" R+ E1 [' C* \: n3 p4 Q [2., 0., 0.], ( V, H- O8 v4 V1 f7 d8 v [0., 1., -1.]]) : @5 q5 Q# L1 g3 ]& x ; G4 i' u. v/ m2 s' T binarizer = preprocessing.Binarizer().fit(x) ' u" f9 U$ N* b. `, P" @( u+ C1 S binarizer.transform(x)% _4 o2 U6 _+ o1 t, `7 A2 C # V# S, J8 T& w+ i binarizer = preprocessing.Binarizer(threshold=1.5)3 l$ K# ~1 h% e) {) P0 b& j binarizer.transform(x)
9 x$ U- f$ g4 z) n0 y D

为类别特征编码

9 w7 s$ l7 W7 A% Y5 A

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

4 @# a f. v# c- G; i* C+ P

OneHotEncoder

' L9 B/ _% c- G& A

弥补缺失数据

$ e7 _- M5 G8 q- C, w* B4 Z4 {/ z

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

, f, ^5 ]9 \. y
import numpy as np: }" V o$ h" s from sklearn.preprocessing import Imputer- E3 L6 p. f. }$ A imp = Imputer(missing_values=NaN, strategy=mean, axis=0) 5 Y! {; n# F* H( _3 I1 B0 o imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])% h" g6 V: u! m' z& h; [ x = [[np.nan, 2], [6, np.nan], [7, 6]] 6 V# [0 _) w3 D0 S imp.transform(x)
- |$ X7 v) v# t3 P$ L( k/ G; e1 {

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

; R/ `' `( b, @
import scipy.sparse as sp 3 \2 q. y7 D$ V! W% | # 创建一个稀疏矩阵 - l+ q# J, P8 { x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]]) ! j6 S4 }/ U; k, S& K7 V1 ? imp = Imputer(missing_values=0, strategy=mean, verbose=0) $ Z. {* S6 A5 v* ]3 F2 D( R, n imp.fit domain name is for sale. Inquire now.(x)% h0 a! n2 k# Y3 a( i9 C x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]): A6 U. T$ W+ g+ B) [5 T imp.transform(x_test)
9 G( Q/ h% m- T& g" U

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

: }4 h* f& W& b2 C! H. {

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

( [6 ~# E4 @' U: m. d

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

6 K2 N! g* I2 \+ E

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

1 P& u1 Z& s6 ?& H5 Q8 t$ C) W: W! i

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

2 z1 r+ M. R- [6 O% p

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

7 P* B4 X/ U: Y2 E: [

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

( v; X6 H7 S! v; P2 G( E, P

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

) F5 T+ d" h: j4 \3 h7 G( K

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

) T8 ~7 r5 @! R1 Z3 c

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

; J! u3 S) e* G' D2 N! c

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

4 H, ~& `5 m4 W. _

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

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

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

' f" h; l* Y, s& U) Z ; U3 S3 x6 v6 b1 H% a 2 E1 F0 ]/ y5 T) E0 l' w- N1 i. L ) C3 B* p1 N/ t' k2 u6 r8 H 9 p: Y9 E; J0 t y
回复

举报 使用道具

相关帖子

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