|
+ b0 c5 v4 k( I: L
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: 3 }# {) G2 i% @5 T5 I# m
归一化是标准化的一种方式,
5 G. x; Y1 Y! ?1 t7 B. _; G9 U5 o 归一化是将数据映射到[0,1]这个区间中, 0 d8 o$ ?9 b) e" P8 G
标准化是将数据按照比例缩放,使之放到一个特定区间中, , ~! d( g4 h: X& y
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
$ t$ C O) n/ y( b6 m+ L1 ^ 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
) L5 X$ Z: d6 e& n2 g 导入模块: 8 {( u/ _$ s% Z/ L n
from sklearn.preprocessing import StandardScaler( v% I* ~4 x! E I( l- o! e
from sklearn.preprocessing import MinMaxScaler
3 U) p9 Q1 _% I3 o from matplotlib improt gridspec* V/ Q/ N& z3 S8 j# z) P A( ^6 {
import numpy as np
6 w1 B1 e$ K. n6 ^, O import matpotlib.pyplot as plt ' Y, G* w" D; Q$ [5 N. ^- A
使用sklearn 进行标准化和标准化还原
! f! Z* Z9 m& `8 I! {* D 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
" n; Y% M2 t+ n4 z' ? std = StandardScaler()
1 x/ h& o& S) Z X data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
4 W" \: C) @! i* z/ f+ Y4 O: o& E! u
# 将标准化后的数据转换为原始数据。
" n5 q4 b1 Z" ]: [0 _ std.inverse_transform() & J" J( s* t# J2 `* G0 b
查看标准化后的数据的均值与方差
# S; {% q& T, w8 q. \ I x_scale.mean(axis=0)# 均值 4 y! M" W. \2 s- V; T
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
: F6 v3 S4 L$ F1 a x_scale.mean(axis=1) + U6 k8 [$ g5 g7 X8 x, j
` ( }* p3 V" O* \( z6 k7 z
cps = np.random.random_integers(0, 100, (100, 2))
6 ?" y% k/ V- ]- U" r" f # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.4 Z0 A& ?' d0 C4 ?' e5 S/ t
ss = StandardScaler()
6 k0 O( H6 c3 S" i std_cps = ss.fit_transform(cps)% Z* ~) e. ?9 T& Q8 R$ J* i8 [
gs = gridspec.GridSpec(5,5)& d/ B/ g: g! H* e/ P- K
fig = plt.figure()
5 r% B! c2 O2 _, Y ax1 = fig.add_subplot(gs[0:2, 1:4])
8 s* T/ Z3 `+ ^/ b$ F( K ax2 = fig.add_subplot(gs[3:5, 1:4])
6 V* k8 `! X7 I$ h2 E ax1.scatter(cps[:, 0], cps[:, 1]). K1 M* U' Q" b9 D
ax2.scatter(std_cps[:, 0], std_cps[:, 1])$ Q1 D2 ^5 u7 b: i5 M+ J
plt.show()
7 P3 |3 i4 z$ h- j- o( @ ` 0 Y) U4 N/ a2 t' Q# U" y3 O" u/ J
from sklearn.preprocessing import StandardScaler& q6 [) Z+ Y3 p3 e0 X" |
from sklearn.preprocessing import MinMaxScaler
* U$ F6 c( n2 I# s8 U from matplotlib import gridspec: G+ |2 z4 x3 N' W7 u0 b2 L& S: t
import numpy as np+ F: }' S5 g: w, O& }6 [
import matplotlib.pyplot as plt4 s9 S$ H* f. i) N' L
data = np.random.uniform(0, 100, 10)[:, np.newaxis]6 a/ \' _, F1 i+ ?# ?
ss = StandardScaler(); E% a2 A; H# O1 V
std_data = ss.fit_transform(data)" e: Q* t- g0 J) w' }5 w
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据2 ^' Y' Q/ ^) `) E
print(data is 原始数据,data). _; ~# s& R2 s) D2 ^
print(after standard 标准化后的数据,std_data)
: w$ I* b9 B- g( }+ B; c5 F print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data); T0 P k" \# P
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
& }1 t& [6 i) v& ]+ w! x, @ 使用sklearn 进行数据的归一化和归一化还原.
" W* X+ x- O* L3 n, H7 l data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据: `, M. ^6 r1 [0 {, m$ X* a4 n
mm = MinMaxScaler()# 创建MinMaxScaler 对象1 |# K6 K5 m: B$ u
mm_data = mm.fit_transform(data) # 归一化数据+ O. J6 @% G" u6 y
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据/ ?0 j& R: l$ G R- X9 k9 h
print(data is ,data)
" F# [) L+ L W( T print(after Min Max ,mm_data)1 y4 H" r- I+ w$ S9 O3 y [: a
print(origin data is ,origin_data) 6 \( y+ i- I6 B) S* ~& |
MinMaxScaler和MaxAbsCaler:
7 {0 I8 f8 |' A( o3 j* u MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) 1 m1 X2 k5 P' r5 I
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 / U' v; X/ O; z7 u9 b2 \! X. j/ X
min_max_scaler = preprocessing.MinMaxScaler()1 l. @# ?0 r: w: P
x_minmax = min_max_scaler.fit_transform(x)
% ]' U& w5 p2 ?7 D" ] x_minmax
5 a4 Q8 Y7 [; K; v- C8 ?; D0 S 对于新进来的数据,采用如下方式进行函数调用: 1 @; a6 p+ ^- m2 i: W
x_test = np.array([[-3., -1., 4.]])7 i: n- ^1 `& b1 S* O! i
x_test_minmax = min_max_scaler.transform(x_test)
$ x6 W! I: E% g9 ^* j8 z x_test_minmax ) G7 |' L' q, v& J& C8 I/ C
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
- k1 n- \0 {$ R8 n max_abs_scaler = preprocessing.MaxAbsScaler()1 {* b3 F% S; t) A4 f
x_train_maxsbs = max_abs_scaler.fit_transform(x)
; \9 P; R) X2 W- d. y/ V x_train_maxsbs
/ S0 ?0 R5 w# f0 z- y # 同理，也可以对新的数据集进行同样的转换
; H* {+ a4 u5 m2 g6 t; u' Z x_test = np.array([[-3., -1., 4.]]) c$ f4 K2 N( h4 x: j5 }
x_test_maxabs = max_abs_scaler.transform(x_test)
6 N& J4 ] k9 e( { x_test_maxabs
9 j/ p7 z6 e3 G 针对规模化稀疏数据
8 l- A3 v4 G7 g: A 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: 3 [6 w u5 [9 v; c
MaxAbsScaler,和maxabs_scale
# L9 c+ T9 N1 m- S/ O! I 针对规模化有异常的数据
: t7 _6 ^3 f5 K' ^" v. {! I9 n# @" G 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. / [) ]) D1 P2 k
正则化Normalization& s% o* K3 A$ K, S3 ]) I
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
+ Y% \; D; Q3 a0 P- N& H+ n x_normalized = preprocessing.normalize(x, norm=l2)
, A9 g N6 O4 Z; B0 e% X/ _ print x" N+ {+ T6 I, B& o, N# \
print x_normalized : a; M; g: V, V+ j
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) # v+ |! R6 o4 F
normalizer = preprocessing.Normalizer().fit(x)
# r% `7 t3 U, D ` normalizer
; D( V8 U; r q" B # 对训练数据进行正则 " x9 k7 P' r# k, X) p3 N6 r
normalizer.transform(x) 4 p, J+ B9 _: U# o" ~" L% q
# 对新的测试数据进行正则 * E- p; R0 K, R8 O, |
normalizer.transform([[-1., 1., 0.]]) 4 C/ o1 y5 \. f' o' C3 ?3 Q
二值化 [0 A- ]( D0 R5 g" w
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
2 w. Q9 n, S+ \$ h6 u9 P# A4 l$ V2 @ from sklearn import preprocessing( A* M" p. `6 Z' a4 ^
import numpy as np9 s! I: M- P$ u, Q/ S; t9 U
4 m# J% z) ?6 D # 创建一组特征数据，每一行表示一个样本，每一列表示一个特征% D, N% a+ E8 I) V/ P6 Q
x = np.array([[1., -1., 2.],
. p% R& k2 p& I" v/ r [2., 0., 0.],: }% I$ m: O% d6 R
[0., 1., -1.]])2 D" ]" n& B' I6 `
3 P- F2 E' _8 t4 b2 M5 D0 w- B( G
binarizer = preprocessing.Binarizer().fit(x)
# x" w0 e# }% n/ l$ e) w binarizer.transform(x)6 j- x7 M5 E# w& T, x- q. C
) x, n0 Z" n4 i& Q! h4 G
binarizer = preprocessing.Binarizer(threshold=1.5); X" ~0 F( o" [# y, j5 w
binarizer.transform(x)
0 H5 l( c% T) T3 `& W 为类别特征编码% K# N1 K! m0 Q) y5 j ]! ^. J, E" l
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
5 `: w4 w" Z( m8 U3 k OneHotEncoder
% b% D7 m) f. g* j1 N 弥补缺失数据" t& W$ r! M' Y4 b5 x
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. * W4 J$ F# T3 [% k( @
import numpy as np9 W7 O& W- F2 p/ P
from sklearn.preprocessing import Imputer* Y* V# {$ i! `' o. d
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
1 d# W3 Q! z, {( ^" m4 S: m imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
* E2 W8 e8 u! v% C- S: j: t x = [[np.nan, 2], [6, np.nan], [7, 6]]
! O: I, K7 d9 h* L- { imp.transform(x)
, C, W1 y* r% K1 ?$ D9 d Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 4 @; u/ |; W, A2 |, H9 i$ E
import scipy.sparse as sp
; h' _2 O c3 r W* ?3 x5 D6 | # 创建一个稀疏矩阵4 ~4 @2 |8 G n1 c; A' h
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])
6 b7 H- P: |- s6 { imp = Imputer(missing_values=0, strategy=mean, verbose=0), `+ _' X9 ^2 D% o
imp.fit domain name is for sale. Inquire now.(x)
' R |/ c6 k$ m- P" V- u% d x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
$ W5 F7 q3 Y5 L& b+ I k! p imp.transform(x_test) 3 t+ }+ R: |/ O4 Z! x" c- j
当我们拿到一批原始的数据
- ]! d; f3 F) P" [! K6 u 首先要明确有多少特征，哪些是连续的，哪些是类别的。
$ s% c/ r4 Y4 G 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 , p3 W. r3 }' H% d$ h3 B% S
对连续的数值型特征进行标准化，使得均值为0，方差为1。
' S- y$ ]% j1 G' G- ] 对类别型的特征进行one-hot编码。 0 O, m' {; O5 f% @, V, b; l- ^
将需要转换成类别型数据的连续型数据进行二值化。 ! w* T% W) Z j& z2 M' z
为防止过拟合或者其他原因，选择是否要将数据进行正则化。
7 T9 j$ c" }3 i 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。 " D' @ Q& h- O& n7 g% R; C& p
根据实际问题分析是否需要对特征进行相应的函数转换。 8 v" D; m* ?& i4 o
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点 ' l6 Z. s9 {+ b$ q8 G+ S* B
因此针对动态的数据可以采用如下几种计算方法:
3 Z& \3 C' i! ~ 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
, g7 X- p$ ^) \6 ~2 i& O0 T; i* P9 F7 j
/ J u- V" r5 B1 A3 x+ X2 H7 i2 w9 `
4 y& r) Q; l% |3 e8 d t$ X+ I( |& t' W8 a" E
|
