|
: L2 R0 f/ D% L: g" Y/ E! t
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: ) X( e7 B T7 Y0 V/ n
归一化是标准化的一种方式, ; ~3 y6 T* U7 u4 c- g, t
归一化是将数据映射到[0,1]这个区间中,
' N6 h1 }/ p& x, q# E/ v 标准化是将数据按照比例缩放,使之放到一个特定区间中, : Z Z0 d' }; h, |& H3 z
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.
% x5 K9 Q' A' P e 如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
K. b% h0 ]. T% X* w 导入模块: % ~* u1 {8 E: w0 c# y. s/ c U
from sklearn.preprocessing import StandardScaler
/ O; B3 B3 Q3 ^$ V from sklearn.preprocessing import MinMaxScaler
W; f7 T+ W3 {4 ^ _ from matplotlib improt gridspec
) D4 x) F1 `/ E% i import numpy as np8 m2 O/ a6 f$ \$ P# W1 u
import matpotlib.pyplot as plt
/ ~. n1 P+ i/ H% S9 `. Y5 I 使用sklearn 进行标准化和标准化还原
! n- a4 |9 w% M8 L( u 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
+ b" x- ^$ x* p3 y std = StandardScaler()
1 ]3 q, A1 `' [) p- \2 @8 _9 i4 ] data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]]), E1 P' \0 v* V5 ^
) h3 E" X! C& I/ w) r0 P # 将标准化后的数据转换为原始数据。
; Q* ~1 r/ Y! j5 p std.inverse_transform()
7 |5 v$ l, X% h) t/ N* W 查看标准化后的数据的均值与方差 ' U9 ^3 U+ P( \3 p! W; \
x_scale.mean(axis=0)# 均值
) h- I& y! G- _! V& b+ [/ u3 } # axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作 / \: p; x& Z3 A' U/ f
x_scale.mean(axis=1) / W. C. W9 r7 i; ^, O( X9 K
`
, v* ?3 Y9 y3 ] E0 F4 B) d8 N cps = np.random.random_integers(0, 100, (100, 2))
3 ?1 `, h9 T, x, g8 b) Z' U # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.' A: ~+ m7 a# [+ d- A$ E
ss = StandardScaler(); n3 y, F6 }6 `" s
std_cps = ss.fit_transform(cps) y2 F3 G. p9 v6 _6 z
gs = gridspec.GridSpec(5,5)
8 @9 o5 \( l9 B- ], F* G1 u, o fig = plt.figure(); P+ Y7 k7 g8 J4 F
ax1 = fig.add_subplot(gs[0:2, 1:4])
! W! t( D! o8 @! a- Z) T ax2 = fig.add_subplot(gs[3:5, 1:4])
F( n7 P6 v3 { ax1.scatter(cps[:, 0], cps[:, 1])" \/ A0 B: u( A$ g3 |5 c7 g
ax2.scatter(std_cps[:, 0], std_cps[:, 1])" g7 r9 G- `: U( _5 f. `
plt.show() 6 J: ?4 ]- ?7 s1 c% j8 Z1 o/ o
`
* {$ @! ^; g& s+ S4 }5 Y0 {+ [ from sklearn.preprocessing import StandardScaler" t# M* I1 j8 z! v1 t
from sklearn.preprocessing import MinMaxScaler1 p' O' @, u( X0 ?3 u+ ^
from matplotlib import gridspec, H" @+ K! c; k- y# U3 T# e
import numpy as np1 ^ N" {/ A9 b9 Y' ^& e4 R
import matplotlib.pyplot as plt' V1 i% I, E8 x' H4 B7 B2 Q& j S2 S
data = np.random.uniform(0, 100, 10)[:, np.newaxis]
- o! J1 z2 g8 t$ M' m5 ~. T ss = StandardScaler()
' z, w" Y9 U: h6 Q- J1 D Q8 X+ @ std_data = ss.fit_transform(data)
6 F% o3 ^5 B) |! ?9 C# ]* R origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
. i/ B! J1 F, [2 B G' u% R& P print(data is 原始数据,data)
+ @+ K) [0 W7 a! B$ J: j5 i% M2 R print(after standard 标准化后的数据,std_data)
0 k' | ~ r$ c print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)3 L! C s+ u- K# \/ S- U9 G0 ~
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
: N" ~3 b+ Q1 j1 u& u1 Y 使用sklearn 进行数据的归一化和归一化还原.
# T5 Z% u& F2 j- k) e# X" W data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
7 h1 u5 Y" t( A0 V+ A5 s D9 o. S mm = MinMaxScaler()# 创建MinMaxScaler 对象/ g: T. O F: F; @8 d
mm_data = mm.fit_transform(data) # 归一化数据6 c8 d9 O) w, ]% E L# D
origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据3 L) l/ g. g. N* S8 B
print(data is ,data), w* {; a* R b, o. [! v$ n! L
print(after Min Max ,mm_data)
0 z* b" D. f8 e9 b. C/ ] print(origin data is ,origin_data) : z3 u; T% _: Y, I" D, L
MinMaxScaler和MaxAbsCaler:
' D5 J) D5 u e- o* N MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) $ b: z1 T* C8 { s/ J
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 - ^* G4 G4 b+ {4 ~3 e
min_max_scaler = preprocessing.MinMaxScaler()! |+ V* H9 T1 Z, l; C( Y I
x_minmax = min_max_scaler.fit_transform(x)7 `" C8 j! W# @7 t/ z7 V
x_minmax
: v8 @" C6 D" H8 A 对于新进来的数据,采用如下方式进行函数调用: - ]6 ?3 c5 e" L# H/ A+ u$ s
x_test = np.array([[-3., -1., 4.]])* \# z- g( }% C# E1 o+ k( M- o
x_test_minmax = min_max_scaler.transform(x_test)
9 k; n6 U S+ A& P/ L/ J x_test_minmax
- u$ N+ ]0 z, z) p5 _ MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
$ f% S0 ^7 { Z7 s) Z. N2 g( b r max_abs_scaler = preprocessing.MaxAbsScaler()
+ z1 y# \" N6 E* B: x9 V" _/ ^* h x_train_maxsbs = max_abs_scaler.fit_transform(x)9 ]9 K9 X5 |% P! l( J
x_train_maxsbs 9 q. Q( `9 e. [( b& d7 M1 l
# 同理，也可以对新的数据集进行同样的转换
$ z/ O+ W0 Q3 s4 b& j x_test = np.array([[-3., -1., 4.]])0 ?7 o) A6 ]+ p2 V* W2 ?& p$ K
x_test_maxabs = max_abs_scaler.transform(x_test)
- {4 b8 r! @; C; W! [# F. B: |# n2 i x_test_maxabs ' J7 t- @) U* r' e3 M
针对规模化稀疏数据$ g# w( q1 x2 f. d+ @2 \/ N" `
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
2 s9 j9 X/ J, k3 Z MaxAbsScaler,和maxabs_scale ; o1 B9 e, ^6 n, j
针对规模化有异常的数据
" o; V: A; {% h% r 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
8 e$ W8 {0 p6 o* K 正则化Normalization U: ~( ?5 Q6 j- G8 R% ]9 x
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 ; M1 C) r% i- Q- o/ W
x_normalized = preprocessing.normalize(x, norm=l2)
4 Z* A: m* i* y2 ~% y1 I& y4 W print x1 W" P5 j7 r$ c5 x% a; {; H9 R
print x_normalized
& s* R3 [# y# E # 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
1 ^5 l/ z* }8 a2 c5 E normalizer = preprocessing.Normalizer().fit(x)" M$ V5 u& j5 ?' b# ?' @5 P4 h
normalizer
& J! t# K K' f4 t6 ] # 对训练数据进行正则
- o4 Z0 J- K6 i+ D normalizer.transform(x)
% S( j% M1 L, `( ~6 Q # 对新的测试数据进行正则
# \+ | f' F( h# T% T1 w normalizer.transform([[-1., 1., 0.]])
7 { t) j5 N6 x) D4 m2 N' d 二值化
, f. r3 X; T9 d& ?& B! r* D' q 特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 , ?3 u* ]/ U' G0 J& J3 g' i0 N: x
from sklearn import preprocessing
9 m1 E1 Z* h! K2 d2 U import numpy as np
& f( _1 X. I( s: k/ n: [- l+ b- b( n& b; l# I1 O
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征
+ a$ ~6 j6 |0 [6 F* k" _ x = np.array([[1., -1., 2.],
: c& r" z& E$ ?# a [2., 0., 0.],) k; d$ ^ Y& U0 S: Q/ _: e
[0., 1., -1.]])
3 _6 V+ g, k) S3 C4 c9 u( t2 d2 E2 ?9 E! L0 g
binarizer = preprocessing.Binarizer().fit(x)+ N) ?6 q+ V) k
binarizer.transform(x)
; C* P! C2 _/ Q$ n; }9 ~
& c% k& c0 v! y binarizer = preprocessing.Binarizer(threshold=1.5)
7 e$ D f2 Q- `; X9 o' G) s binarizer.transform(x) $ k, C5 P1 u4 R$ I* i
为类别特征编码( u2 ~0 i6 X1 i
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
4 }. g' G) _2 K6 {/ { OneHotEncoder 9 _/ v: K: }' {5 [
弥补缺失数据. E% s- H7 }) i0 o! O* u7 O( w+ W& Y
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
1 q, N* Y7 x. a import numpy as np) u# [1 `! P O1 T
from sklearn.preprocessing import Imputer/ |/ W: w. `4 Q6 D
imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
5 X: m4 f& a0 x4 M/ a imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])0 A5 q4 Q: R& Q! n% f1 ]
x = [[np.nan, 2], [6, np.nan], [7, 6]]; K* f- T6 r: _/ ?
imp.transform(x) ( c& d. I0 E O; b" S! N
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值
0 i' [1 S$ w" G" B. y6 M import scipy.sparse as sp
7 r X X: a# D/ ] # 创建一个稀疏矩阵 q9 p3 f+ \% C6 N g! ?# J
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])6 n: F8 D1 z# a8 Y
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
, t' d) ^- ^5 d% P imp.fit domain name is for sale. Inquire now.(x)
1 w. \7 }, s% n; V+ L: j x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])
4 i% B0 B; e9 E5 B. X imp.transform(x_test) 2 K: {; _5 O7 f- s$ H% [
当我们拿到一批原始的数据 ' a) s, Q9 K) H( V$ S1 _% q6 G
首先要明确有多少特征，哪些是连续的，哪些是类别的。
. Z0 X3 x& d5 M+ Z. [! H 检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。
* w- [$ o7 ^8 i% w" H: t 对连续的数值型特征进行标准化，使得均值为0，方差为1。 . k* C: |0 m( F6 e
对类别型的特征进行one-hot编码。
0 E( n) }1 o2 O; J 将需要转换成类别型数据的连续型数据进行二值化。 # V- v& L) d* ?2 I) P8 m& W- H9 _* @
为防止过拟合或者其他原因，选择是否要将数据进行正则化。 6 w7 q4 s9 Z% V- h# M
在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
8 Q4 o! L- R2 P @+ [ 根据实际问题分析是否需要对特征进行相应的函数转换。 & A+ R8 n- T' J- s3 m" T9 Y) }
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
2 Z$ T. }5 T. \( b 因此针对动态的数据可以采用如下几种计算方法:
6 r: c) }# N3 T( h, { 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客 9 \) B3 H/ z$ m5 J: k: X
' E# R4 m7 T+ e! S0 B
% e$ _% e# a8 U6 U
5 s3 o* l2 K2 M! m; {" ]9 v# J9 F0 g- n9 U! g# C; [
| 
