sklearn Preprocessing 数据预处理

sklearn Preprocessing 模块

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

标准化和归一化:

/ G3 k2 f- |6 W8 @

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

5 c8 C: Z; G5 L+ K1 k2 Y

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

' a, D6 O: G& n$ j- B

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

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

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

0 `; ^9 [1 l3 m# P: Y: l# U

导入模块:

from sklearn.preprocessing import StandardScaler & A1 D* @+ @7 q1 M3 `" H( Y from sklearn.preprocessing import MinMaxScaler from matplotlib improt gridspec # k! ~( u1 T: g6 ~) Y! _ import numpy as np : K m0 N3 x& Y i import matpotlib.pyplot as plt

* F% {# D- r7 \" y6 C g" m% \+ G

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

标准化的过程分为两步:

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

x_scale = preprocessing.scale(x)

std = StandardScaler() data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]) . ?6 Y/ _" l4 e# S. G% x # 将标准化后的数据转换为原始数据。 ( D; m( O: Q3 Y7 |! {) t std.inverse_transform()

( c9 ? X2 S$ i

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

+ N( m0 g" J$ X5 K- A; ]7 w

x_scale.mean(axis=0)# 均值

9 k2 B+ k) i+ _. X q

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

3 G8 t* t1 I1 |2 g1 i3 G

x_scale.mean(axis=1)

! d$ L1 B, b8 V. t9 I

`

. ^. [: ~6 n( m

cps = np.random.random_integers(0, 100, (100, 2)) # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集. 5 L% s b; B) y ss = StandardScaler() std_cps = ss.fit_transform(cps) ; t* T6 F1 Q# r7 e4 S7 i { gs = gridspec.GridSpec(5,5) 1 t8 l0 {1 R# y: e( R3 @( E8 g% A K fig = plt.figure() $ v) C3 c# H2 {' l. K; U' { ax1 = fig.add_subplot(gs[0:2, 1:4]) , S, n p/ P! T ax2 = fig.add_subplot(gs[3:5, 1:4]) ax1.scatter(cps[:, 0], cps[:, 1]) ax2.scatter(std_cps[:, 0], std_cps[:, 1]) ' G* S0 f' }+ H' n, o3 T plt.show()

o6 P6 E7 z; t9 C. o

`

from sklearn.preprocessing import StandardScaler from sklearn.preprocessing import MinMaxScaler from matplotlib import gridspec . h* Q; }) a6 c- X import numpy as np import matplotlib.pyplot as plt 3 l# E5 B2 A E3 P+ v: p4 h data = np.random.uniform(0, 100, 10)[:, np.newaxis] + q' ]. v, z# X( c! o0 ? ss = StandardScaler() std_data = ss.fit_transform(data) origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据 print(data is 原始数据,data) # f" {; M" o3 |' C- }- n H print(after standard 标准化后的数据,std_data) print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data) T- \+ [0 e9 o) J. T print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))

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

3 Z& Z/ I a P8 P4 b3 Q

data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据 2 R+ w' ^% e% m$ u2 a" C( P: | mm = MinMaxScaler()# 创建MinMaxScaler 对象 ; |: N2 _! n, ^* l9 f mm_data = mm.fit_transform(data) # 归一化数据 5 C! H0 n" f7 a4 Z origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据 print(data is ,data) print(after Min Max ,mm_data) - k# L2 g* R& m$ s2 a print(origin data is ,origin_data)

MinMaxScaler和MaxAbsCaler:

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

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

min_max_scaler = preprocessing.MinMaxScaler() x_minmax = min_max_scaler.fit_transform(x) x_minmax

9 N* i: Q/ R/ O

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

3 v# K. k9 I+ d1 v/ s n/ c

x_test = np.array([[-3., -1., 4.]]) E* f* H/ F: Z* h x_test_minmax = min_max_scaler.transform(x_test) x_test_minmax

! {" m0 B' {. S/ t' r" q; D

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

! [' E8 s4 L3 C! I

max_abs_scaler = preprocessing.MaxAbsScaler() x_train_maxsbs = max_abs_scaler.fit_transform(x) 0 |5 _' @ `2 x5 \* W x_train_maxsbs

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

; ?# v" t$ P) W7 v

x_test = np.array([[-3., -1., 4.]]) ! Q7 y- X& k, J! T, b* j x_test_maxabs = max_abs_scaler.transform(x_test) x_test_maxabs

针对规模化稀疏数据

" [1 j/ L4 l4 f' h, P7 ]! k8 K

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

9 v" n0 W+ ]. M# b

MaxAbsScaler,和maxabs_scale

$ ?1 \! ]8 I. S

针对规模化有异常的数据

* V: k1 K. ?1 C' {: A" u$ c+ q8 }

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

正则化Normalization

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

9 @% ^) M& g% _. A! @/ \ R2 O% v

x_normalized = preprocessing.normalize(x, norm=l2) print x 0 z& q# V$ H: S- n5 ]4 Y5 Q$ y9 S) u print x_normalized

3 A- |" R1 Q' _$ {: c8 n/ Z

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

0 K2 n. d! _" H. ?$ q

normalizer = preprocessing.Normalizer().fit(x) N5 t4 P! ]' ~" z8 t) S5 Z normalizer

4 t* k1 b0 e7 S. c

# 对训练数据进行正则

- R x! D* k% O6 K% u* h3 g, z- D

normalizer.transform(x)

* b6 w) W% Z9 E( o! ~7 J2 m

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

normalizer.transform([[-1., 1., 0.]])

# G. y! w% e- @/ Y( `& e/ _

二值化

2 n+ n9 r' ^: _9 N# M' N1 y$ }1 x

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

5 N# I9 e2 X: _7 K* @. T

from sklearn import preprocessing - K' h4 ]8 Z; Q m import numpy as np " p+ _$ U( |$ p4 ]$ Z! j # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征 0 F: ^) e# Q% B x = np.array([[1., -1., 2.], [2., 0., 0.], [0., 1., -1.]]) 9 O" y3 l. N4 f& \: P binarizer = preprocessing.Binarizer().fit(x) binarizer.transform(x) ' o# @6 y0 h6 P+ e2 e E & A3 v" A! V) }: S0 W; A( F binarizer = preprocessing.Binarizer(threshold=1.5) binarizer.transform(x)

为类别特征编码

, C' y/ c" o) k& U* A

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

: G2 [. F$ I( O5 g; {5 y

OneHotEncoder

* T7 p6 f; a, y

弥补缺失数据

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

import numpy as np H) F# C- h# o3 @$ O% u from sklearn.preprocessing import Imputer " M2 P$ U7 a0 B1 Z imp = Imputer(missing_values=NaN, strategy=mean, axis=0) * Y# ^ V( W; v5 E* ^2 g- a imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]]) 6 L: @. R j l5 M: V5 N x = [[np.nan, 2], [6, np.nan], [7, 6]] ( o$ u# C/ i" ~- u imp.transform(x)

$ C2 Q. L2 Z3 ]1 l. R* J0 W! ?

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

9 d5 U6 l' x/ o/ ?

import scipy.sparse as sp ; s3 v+ X; |4 [. P b8 U # 创建一个稀疏矩阵 3 z; J4 f; a1 b m/ B x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]]) imp = Imputer(missing_values=0, strategy=mean, verbose=0) ( J F& R8 L% O* S4 z imp.fit domain name is for sale. Inquire now.(x) 5 ~) b. Q+ e5 P T+ j x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]]) / [6 Z. i5 T2 m( t imp.transform(x_test)

( J1 N; _/ O, j5 \* C

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

% c; n8 q0 ], v+ ^- z

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

, |: T$ ?9 P- O4 H7 \

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

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

! a4 T4 d3 |' d0 v5 n( ]

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

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

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

5 x# Q3 m8 y9 h2 ?

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

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

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

* V* g1 {! B" @0 V7 W" l' R

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

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

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

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

# d& x# u& F2 Q 9 d. n9 E h& u% k* z" {6 i: h4 ^ " n9 `: d$ q! i* d1 W