|
6 ]0 j. j; N/ H: C. s* z
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化:
) O# v3 N8 X. M7 z9 x 归一化是标准化的一种方式, 5 Q! M' B5 g1 W' D" J( w# }0 t
归一化是将数据映射到[0,1]这个区间中, ) y9 C6 m# m6 t
标准化是将数据按照比例缩放,使之放到一个特定区间中,
# H- \$ h, \" d* Y; @ 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. # F4 {% O1 `1 d
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.) b! F! W9 ~5 ~+ h$ D& c
导入模块: * V" |: P+ u3 P& Z
from sklearn.preprocessing import StandardScaler& M1 c8 |7 W3 E( @# @1 G) _
from sklearn.preprocessing import MinMaxScaler2 s7 Q/ j# R; Q$ L7 O9 n! ?. X9 A% F
from matplotlib improt gridspec' n) H) D% a+ D; W8 O+ y3 ?
import numpy as np8 j l t3 q6 Z3 o
import matpotlib.pyplot as plt . d' w) G2 B' z. |
使用sklearn 进行标准化和标准化还原% k8 P$ S. f0 K; C$ _
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
7 K7 v1 Q- Z% r; P3 o S std = StandardScaler()" i( Z% n( Y" p' O% J2 b
data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
s0 V& h; W0 [& m4 ^! q% l& f; [, p8 k0 ]5 {4 R3 w! J) v) i" |3 Q- S
# 将标准化后的数据转换为原始数据。. j: |, J" Y: k" e8 o, M
std.inverse_transform() & _3 v4 N2 g p
查看标准化后的数据的均值与方差 * n, t. J& t1 V' B+ Q. m x: @/ r
x_scale.mean(axis=0)# 均值
% O; r! |0 r, S8 y; Q! _3 v; w # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
$ M& @0 c2 B, M/ I x_scale.mean(axis=1)
& G4 J2 G: V5 t5 S ` - }" h4 O$ e% c% {. P6 ^# S/ L# A
cps = np.random.random_integers(0, 100, (100, 2))
' t. ~6 |3 U* Z4 }0 s% ~% s* h# v # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.& |: _& \1 D* i, U4 b( v
ss = StandardScaler()
% \' E8 E- C- d9 y: \/ n% W std_cps = ss.fit_transform(cps)
1 R+ l6 Z" S2 p( T; t1 C gs = gridspec.GridSpec(5,5)
0 K6 u5 {+ [! q6 N0 ?% H fig = plt.figure()
4 Y1 l: C$ M. p% J! C7 y3 H, e ax1 = fig.add_subplot(gs[0:2, 1:4])* \1 A) W- J) l5 _: e
ax2 = fig.add_subplot(gs[3:5, 1:4])
$ d4 H. U1 e% y! k) N ax1.scatter(cps[:, 0], cps[:, 1])& A. K) @( Z1 v/ y( Y$ h
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
7 r6 g, x. [" E$ \9 Y plt.show() ) {* |# l' E/ k- @
`
- X1 k" X' v( U8 {9 w3 w from sklearn.preprocessing import StandardScaler
! l" U' T0 F7 T/ n" f from sklearn.preprocessing import MinMaxScaler
( k; C/ l) I) C/ E: u& t from matplotlib import gridspec
. a7 o. @# A- `+ n3 ?" l( F import numpy as np
% }5 r/ A+ i9 {. S import matplotlib.pyplot as plt
% Y* D$ S7 E6 S. Q, m7 P' h data = np.random.uniform(0, 100, 10)[:, np.newaxis]
/ m3 H# R/ t3 e ss = StandardScaler()- A2 @$ F! Y! s8 v. z" b; Z% Z" d
std_data = ss.fit_transform(data)
m* Q8 Z* d. r! [ origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据& O' C9 p- k3 i
print(data is 原始数据,data)
7 B3 Y( {. q" G7 q$ V! i v print(after standard 标准化后的数据,std_data)
& t$ L' _- Z1 i* `$ l print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)) U8 }8 L- S- e v! [9 _8 w% ]
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) 1 ?1 Y% H( d9 c3 I& C
使用sklearn 进行数据的归一化和归一化还原.
$ q5 i' Q3 N* c0 j7 c data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
" M7 [& {- j) ] mm = MinMaxScaler()# 创建MinMaxScaler 对象
$ }, D R! V$ z9 ?0 R: [. } mm_data = mm.fit_transform(data) # 归一化数据+ K) j9 t; C- k/ X7 L' H
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据 w$ z: t" m# l9 q( A% ]& ]5 G
print(data is ,data)+ B3 n j$ E: \: }, J! v" G
print(after Min Max ,mm_data)2 [4 O! L5 c4 s8 L& h
print(origin data is ,origin_data) . D4 G4 B9 Z& f7 K/ u& @9 C8 j
MinMaxScaler和MaxAbsCaler:) N* } J) w& E6 N) a5 A" r0 X
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
* B6 f; A9 s* m4 G4 M MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间
5 n9 o' B9 i6 X( s& S$ Z/ I min_max_scaler = preprocessing.MinMaxScaler()1 o! h4 s+ q' o
x_minmax = min_max_scaler.fit_transform(x)& p( _: g4 D3 X- C! O% L- @0 m- F2 w' z5 M
x_minmax u9 X; n9 F( |) d4 H% U! M
对于新进来的数据,采用如下方式进行函数调用:
6 i* ` ^: @( V* H6 O# ~ x_test = np.array([[-3., -1., 4.]])% V( D2 O9 x- C
x_test_minmax = min_max_scaler.transform(x_test)
t4 y$ a4 [0 o, ~ x_test_minmax 6 ?: h4 A8 D$ c4 `& o0 e7 i7 c) e
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. ) V# ~& r2 X6 N
max_abs_scaler = preprocessing.MaxAbsScaler()
/ {+ F; b# \/ C! o x_train_maxsbs = max_abs_scaler.fit_transform(x)
) L2 I; {) @) ] x_train_maxsbs
% L& j2 A6 z$ Y+ i' A # 同理，也可以对新的数据集进行同样的转换 4 o# H- F4 ^3 b2 C; D
x_test = np.array([[-3., -1., 4.]])& P0 F: F7 n- } f% G: ~$ F
x_test_maxabs = max_abs_scaler.transform(x_test)
7 E3 E3 T* ~0 E3 E) I2 T S8 s' K x_test_maxabs
! i, ]; J( k0 k" a5 {& v 针对规模化稀疏数据
4 I; ?9 _! q+ d+ R 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: ) l V3 S2 T% N. m4 s
MaxAbsScaler,和maxabs_scale W+ N7 z; i* \* d4 R- Q2 I/ P
针对规模化有异常的数据, V" G4 k0 X8 v
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
+ s$ W& A* {1 v' N8 p7 B 正则化Normalization
8 W) ?. Q9 J, t0 B3 M 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
$ |* X3 a" u/ N k2 o x_normalized = preprocessing.normalize(x, norm=l2)
7 g5 }; V0 O" j! V print x3 m& | B0 B: Y/ q/ M
print x_normalized + c# q. C) J; `# ?% r
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
! |% M" l0 C& w0 F0 \0 S% \) J normalizer = preprocessing.Normalizer().fit(x)
/ a3 R: t; u D3 u) m w5 R, N normalizer
0 X' t$ l# P6 } # 对训练数据进行正则 ; V" h! [% i1 ?7 \
normalizer.transform(x) % g9 P1 T+ ~: y/ v
# 对新的测试数据进行正则
7 i3 l. E; U$ R# W7 c4 N1 @ normalizer.transform([[-1., 1., 0.]])
2 {6 g# i' F6 |, j! l 二值化
: p) [; a o& |. v$ K3 V 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
5 b* L+ H0 V+ i5 N/ u" p1 t* | from sklearn import preprocessing
! v% a. G, l2 M- P* h. [/ U# ]) C import numpy as np0 [3 s5 U& g5 k6 T+ S
+ \" Y _" E% \; D5 g # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
- I! _' Q1 O* T1 @ x = np.array([[1., -1., 2.],
$ F% e' i3 |3 Y4 v8 g# C; ` [2., 0., 0.],& ]0 O, F1 N" A/ ^/ B; f. V/ A) k2 d. B
[0., 1., -1.]])
\& t$ x2 _% _# A5 |
, k! u2 }+ S7 M e) c, M! V binarizer = preprocessing.Binarizer().fit(x)
' v1 ^ J8 S$ W9 ?4 E# p binarizer.transform(x)
2 e$ w$ u; q. z7 t* E3 N
& U* b- |5 k1 v7 |% p/ H3 x binarizer = preprocessing.Binarizer(threshold=1.5)
5 n* s* G+ F* s5 ?+ d; B' P binarizer.transform(x)
0 Y2 I% ^ v- g4 \. P4 S5 p0 V. N 为类别特征编码
# E3 n# A! I* _ t) u, J* j2 a (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码. ! w+ B) U1 j J( g s5 D3 ?6 h. B8 t
OneHotEncoder
7 ^& m5 }; s; X 弥补缺失数据
. x9 `+ h. B R# n 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. 3 D n- d5 }# D) |9 S
import numpy as np
5 i( n6 s: w( l+ _. ^; J( B from sklearn.preprocessing import Imputer
|) f$ y7 w, w# \0 ^* r imp = Imputer(missing_values=NaN, strategy=mean, axis=0)! B3 b. V$ U7 h1 k8 q; G3 H6 Q
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
3 W' P8 K4 \: ^; O7 }. z' S x = [[np.nan, 2], [6, np.nan], [7, 6]] \# a8 G |/ F
imp.transform(x) + H9 q3 a h6 T, ~. i3 ?
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 * E; R8 L! h3 m1 K% v5 d
import scipy.sparse as sp
; G7 R8 \! y4 h2 R; K: Q # 创建一个稀疏矩阵2 g0 n, j7 q5 E
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
# T3 ? y1 s V imp = Imputer(missing_values=0, strategy=mean, verbose=0)! H8 Z2 q9 y/ B/ i* v5 }
imp.fit domain name is for sale. Inquire now.(x)
0 N2 G: _! ~$ X/ K) N7 p x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
1 V) d# { W2 F: ] imp.transform(x_test) 9 K4 A+ d% r( b: O3 R l: N
当我们拿到一批原始的数据
5 f3 y/ e s0 O 首先要明确有多少特征，哪些是连续的，哪些是类别的。 / e2 w/ u, W! w& {
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 # t# k1 `( [6 w( a
对连续的数值型特征进行标准化，使得均值为0，方差为1。
/ K- H- k% q% ?3 I! s+ Q, D2 P 对类别型的特征进行one-hot编码。 ; y+ L+ S* H1 l/ n% s% q1 O
将需要转换成类别型数据的连续型数据进行二值化。
; P- n2 C" i+ N7 @ 为防止过拟合或者其他原因，选择是否要将数据进行正则化。
# ]4 S: k2 f+ `. D- B6 C. \ 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
/ D3 G! l1 I6 |, o6 x 根据实际问题分析是否需要对特征进行相应的函数转换。
' v. _ V4 k( U5 V 标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ' L3 x/ s8 z/ \+ o" Q
因此针对动态的数据可以采用如下几种计算方法: 5 [7 p! t9 x" m* {; c: o# M
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 % O/ Q- p* c; ~9 }5 O
+ n$ o$ v/ o8 S8 M
. _! D* `; U$ t9 R* O5 `5 [6 `
6 H( i9 H7 s a4 S3 I- j
$ \% K R& L) @9 H6 X" U | 
