' {: c V/ L( c& U6 h, B
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: / P2 }7 N$ B) p. o) {
归一化是标准化的一种方式,
7 \7 f$ o- e3 I L/ Q5 z 归一化是将数据映射到[0,1]这个区间中, % M7 X( P+ l5 D5 o2 Y) L
标准化是将数据按照比例缩放,使之放到一个特定区间中,
7 J2 l' ?7 w' z* d/ Z# X 标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. : d7 R* S9 W1 n
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
5 y3 C2 ~" ^# F- |# H: A- X3 S. T 导入模块: - Z3 j2 Z" c! Y4 l2 |: k
from sklearn.preprocessing import StandardScaler
X+ q: @2 ]2 i" k0 A from sklearn.preprocessing import MinMaxScaler
. ]- G. x% l* y& O: W. A# F% @ from matplotlib improt gridspec: i( }+ V- e1 G" o3 y0 A3 V
import numpy as np
8 @% G: J# p9 D4 O2 B6 @ import matpotlib.pyplot as plt 2 w" x8 |5 L9 ]; f
使用sklearn 进行标准化和标准化还原
6 L$ W( H9 _ D5 q+ ` 标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的x_scale = preprocessing.scale(x)
3 u5 f1 N4 s9 O7 y std = StandardScaler()
+ ]/ x! o$ T/ V4 s8 \) J9 N3 Q data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
" e5 I/ t0 f I% R; w1 C' M% R$ ]" ~- f/ G+ U% u+ B# ^- M
# 将标准化后的数据转换为原始数据。
. N o/ q! L, d8 I3 m/ b std.inverse_transform()
1 ]5 X8 J2 t+ B2 ? 查看标准化后的数据的均值与方差 ; A0 l5 Z* u! k
x_scale.mean(axis=0)# 均值 " p# Y/ |" q$ N* q9 s
# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作 6 A ~, a# A3 p4 r- U
x_scale.mean(axis=1)
9 R" S$ N/ N7 |1 u ` 5 E8 {4 e# v' @1 R! V. {8 b& ?
cps = np.random.random_integers(0, 100, (100, 2))) ]7 P& i9 }& d8 i! n# c
# 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.; R) J9 E6 E! }+ O
ss = StandardScaler(), F8 G8 @7 k7 I
std_cps = ss.fit_transform(cps)! S+ C7 ]4 z2 w( P
gs = gridspec.GridSpec(5,5). C6 A7 _2 Y2 H) Z2 C/ V
fig = plt.figure()
( d6 s5 Y: _/ Z! s6 i ax1 = fig.add_subplot(gs[0:2, 1:4])) F- R" { u# D% Z! @$ t
ax2 = fig.add_subplot(gs[3:5, 1:4]): D3 c" l2 d! U' R: D
ax1.scatter(cps[:, 0], cps[:, 1]). D; z: w: @' d+ q4 ^
ax2.scatter(std_cps[:, 0], std_cps[:, 1])
4 B3 }2 [0 p5 r0 C& Z# x) N0 \ plt.show()
l) I8 A, n* B1 v( J7 ~5 y `
& y$ _" L/ D, L Z7 p: l from sklearn.preprocessing import StandardScaler2 D% |$ H( w/ S2 w& y- u
from sklearn.preprocessing import MinMaxScaler, f6 d% c x( q0 A: g8 O
from matplotlib import gridspec0 I( k2 ? ~ T! X4 {
import numpy as np& a% W, l/ j% h
import matplotlib.pyplot as plt( O. }) Y8 e t Q4 c
data = np.random.uniform(0, 100, 10)[:, np.newaxis]/ Q: }5 S. a" Z/ S6 P; A
ss = StandardScaler() O( g' m1 H8 O" i. `
std_data = ss.fit_transform(data)
/ p! r, j' d' Z' r. ], w# _ origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
; c% v! \; ?7 a" ? print(data is 原始数据,data)
$ u2 A. w7 h7 f$ P' K2 ?% M7 ^ print(after standard 标准化后的数据,std_data)* B& r3 p/ e0 D
print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data). v7 A# W: h. A: N; q
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data)) : Z# [, D1 c% |- d$ z) k
使用sklearn 进行数据的归一化和归一化还原.! f4 U2 y P# O/ D' |
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据
- z' t2 @! W. g; `3 R) c mm = MinMaxScaler()# 创建MinMaxScaler 对象$ ?& h+ n/ y6 r8 v2 l
mm_data = mm.fit_transform(data) # 归一化数据
, v. k$ f& t' D+ ^& y* B5 I! u origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据& [. l1 }+ s( N' T" o0 I# K8 }
print(data is ,data)
* ^/ B( @* O: [9 c) F" H print(after Min Max ,mm_data)
D. m! |7 f5 s$ c' i" A. W% Y print(origin data is ,origin_data)
4 J6 @! g, m5 D. e V9 Z MinMaxScaler和MaxAbsCaler:9 W# G1 D% F5 i) K' o1 @# V7 m( f# T9 |
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)
# E1 C! M7 L/ L9 d( u MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 - T* Y% t+ {% @" ~
min_max_scaler = preprocessing.MinMaxScaler()# e& g$ W# H U2 d/ q4 }' B( X( w1 R
x_minmax = min_max_scaler.fit_transform(x)
. i) q' N4 w7 I: Y7 ` x_minmax
+ k/ j% H8 Z3 Q3 F1 N1 ` 对于新进来的数据,采用如下方式进行函数调用:
5 L* A$ X0 B8 } @- A x_test = np.array([[-3., -1., 4.]])( Q B8 W L& X- c5 @- b8 O$ a
x_test_minmax = min_max_scaler.transform(x_test)
% h: v+ g) v7 \( L1 w) F3 z: t' i x_test_minmax 4 T+ y6 H7 Z( ~( _8 {( D
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义. 7 N: h& c* c, N! D* v' [$ {4 M0 T
max_abs_scaler = preprocessing.MaxAbsScaler()/ ~, c' W# @" W4 H* _% i/ W9 ~
x_train_maxsbs = max_abs_scaler.fit_transform(x)
" N0 g' k7 x- v- _( r x_train_maxsbs / X. n5 z( X- _4 l" a
# 同理,也可以对新的数据集进行同样的转换 % i1 |1 R9 p" I- s, x
x_test = np.array([[-3., -1., 4.]])
5 H8 W7 X g. f# U8 U x_test_maxabs = max_abs_scaler.transform(x_test)
) k9 R, w q! O8 }6 H9 w x_test_maxabs 1 T* e% q( ^# i0 p n) [
针对规模化稀疏数据
2 ^/ L* h3 [- U 对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:
( ^0 f* d2 ?) U$ V MaxAbsScaler,和maxabs_scale & _: f6 K3 w# r
针对规模化有异常的数据. w* r; `; r( N% p* p$ c
数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据. ; u: P, N* E5 J
正则化Normalization
P# v1 Y) p. h# o* Z6 K* F 正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等
" h; s: c$ R& T: t' G" @ x_normalized = preprocessing.normalize(x, norm=l2)$ s* |0 I% v* n8 s# q
print x
" u+ g4 e) a; d0 P: [ print x_normalized + L5 D' W+ v; g: u5 I, g% o! \
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)
# ?0 }7 L! _* U9 U normalizer = preprocessing.Normalizer().fit(x). J# o |4 q0 H+ I( E4 G
normalizer
" {0 K9 F+ O, d, N# ` # 对训练数据进行正则 8 @8 ~ J' X8 `. K
normalizer.transform(x) 5 f9 U c! k2 x7 W& [
# 对新的测试数据进行正则 4 K1 O: P4 Y1 ? d8 W2 A S+ ]
normalizer.transform([[-1., 1., 0.]]) 0 l8 S; k6 e& _5 t
二值化0 Z' X E. @2 l
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值
# _. {0 q" ^$ p7 \! ~( s& x from sklearn import preprocessing
& ~6 V# f8 \% J, W import numpy as np3 [- v- z1 m6 j& L- `. s0 U
' @1 z; p& s; _( q1 w
# 创建一组特征数据,每一行表示一个样本,每一列表示一个特征0 c! n$ Z1 z. ~6 X- c$ F' t+ ] s0 P
x = np.array([[1., -1., 2.],
" z$ I* J. l' m8 j Z: O: Z( t [2., 0., 0.],4 v( h8 o+ L" _( K- g9 z" g
[0., 1., -1.]])
, f2 X: }3 N, P$ U' }9 d' U6 m, R" t* C, ? f( T5 R
binarizer = preprocessing.Binarizer().fit(x)
; C5 L# Q% o E& i4 Z binarizer.transform(x)
$ i4 b2 B/ j+ s6 u
0 T p5 E+ a9 O u binarizer = preprocessing.Binarizer(threshold=1.5)4 [) K7 \# @2 o% `
binarizer.transform(x)
; `% j! f9 E( F' o& }) ~ 为类别特征编码
' n( w2 J0 f' v4 I w8 } (比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
3 M% g) @! e7 X1 l OneHotEncoder
/ C% R% C% o# x 弥补缺失数据
& Y; N& X$ }, J( [ 可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.
5 G/ y3 |. C7 W import numpy as np
" m. j/ U' j$ z$ u# o from sklearn.preprocessing import Imputer
+ B) [! v( o/ j: u! V imp = Imputer(missing_values=NaN, strategy=mean, axis=0)8 s7 P. q" [3 w
imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])6 m# K) |' v! W
x = [[np.nan, 2], [6, np.nan], [7, 6]]
! s7 a8 {5 N$ s5 z& a- Q3 v! z imp.transform(x)
5 K, i8 u0 I" d8 ]5 O L) S5 r. B Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值
1 `$ f+ U. d1 {' Q import scipy.sparse as sp
* R3 w" v7 X6 U! {0 s # 创建一个稀疏矩阵+ W3 o, B. K5 p. q2 @' D+ o
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])) D9 G- j X" O# ]/ u
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
5 k+ d& }4 Y3 u& q imp.fit domain name is for sale. Inquire now.(x)3 z. E% U' z l6 {" Q( w
x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])' S& F# C1 b9 M) D5 F( \
imp.transform(x_test)
! {# F% O# E- v2 ]0 l, t' \ 当我们拿到一批原始的数据
! g [+ S+ g& K( Q0 n 首先要明确有多少特征,哪些是连续的,哪些是类别的。
$ Y% L$ U" s x; D, o 检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。
- X8 d( c/ p; g" i 对连续的数值型特征进行标准化,使得均值为0,方差为1。 % n0 @, Z, e/ T/ e
对类别型的特征进行one-hot编码。 ! l5 P& l) \: O
将需要转换成类别型数据的连续型数据进行二值化。
' O. Z- a1 n" b/ U6 @ A2 C 为防止过拟合或者其他原因,选择是否要将数据进行正则化。 + ?1 d* ~, P7 ^ d7 c/ k) q5 H
在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。 + d) P i5 S1 w3 C2 Y
根据实际问题分析是否需要对特征进行相应的函数转换。 ( f/ i+ X9 h# v3 V7 U9 N( ~! |& h
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
U4 t2 S2 Z: e 因此针对动态的数据可以采用如下几种计算方法:
0 k; t! R- ]2 W* t, E 1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客 6 h& }* k8 `( w; }
7 F" ~6 W& Q* t( M
3 v, m( X) l, v9 U
( `7 i. C6 i7 E' E' [0 F1 J9 {" `0 z3 w' R3 S9 V' T( P
|