|
( A6 F' a" N7 _$ V2 S
sklearn Preprocessing 模块 对数据进行预处理的优点之一就是能够让模型尽快收敛.标准化和归一化: & G" ^+ a- l6 h2 }4 I8 [& g
归一化是标准化的一种方式, ( W8 u, Z9 A% f2 |1 M
归一化是将数据映射到[0,1]这个区间中,
1 R( D& ^% I! u- Q) a2 |, U 标准化是将数据按照比例缩放,使之放到一个特定区间中, 9 o, C+ D/ ?9 \$ O/ _( O
标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负. ) b7 f8 h! r8 \# ]0 n' D
如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)
( K8 K' F3 [% l; Y0 p- h 导入模块: . C6 X/ d- p/ G# V' M$ L
from sklearn.preprocessing import StandardScaler& N% V: B$ h" f5 f, t1 }# R
from sklearn.preprocessing import MinMaxScaler
~/ [7 o: Q8 W& z" w& b3 j from matplotlib improt gridspec
C. v6 V6 Z, a( |5 y import numpy as np0 B1 g% A& j% y/ r7 P- ~. w+ F$ ^
import matpotlib.pyplot as plt
3 M7 D' s) _, t' E' ^' g4 r. `& J 使用sklearn 进行标准化和标准化还原, ?8 t; i5 O/ I' y
标准化的过程分为两步: 去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布，注意，标准化是针对每一列而言的x_scale = preprocessing.scale(x)
6 t, e! X8 k8 }! C- Z std = StandardScaler()
# F! e0 H7 ]2 @7 c, U7 T data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])
% {% R: H1 ]3 I9 f6 r5 ^5 o/ f1 r
# 将标准化后的数据转换为原始数据。1 _$ a% i& N, S- }7 Z; M9 q- y
std.inverse_transform() * y( S' q. h3 z- ~# l! F
查看标准化后的数据的均值与方差
6 z3 T: @2 A3 J0 O# [5 _ x_scale.mean(axis=0)# 均值 3 t F; \+ p- ?
# axis=1表示对每一行去做这个操作，axis=0表示对每一列做相同的这个操作
! k9 Y/ J9 {* v* B/ ?* Z4 p( { x_scale.mean(axis=1)
) B4 y9 E! I$ B; S8 W- l( z ` 4 a' \5 U" M( V8 @ k
cps = np.random.random_integers(0, 100, (100, 2))
$ p9 p% N9 f" l # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.
/ f3 W# X% S' i) l! A8 I3 \ ss = StandardScaler()) a6 m3 {, u4 ]+ ^- x2 e8 m8 r
std_cps = ss.fit_transform(cps)
/ H1 ~4 [. |2 x: I gs = gridspec.GridSpec(5,5)
" z7 {- q. [! X( I$ V fig = plt.figure()8 j1 `. ?4 Z# J+ V; Z" \9 U
ax1 = fig.add_subplot(gs[0:2, 1:4])
* j: L% O/ }2 K0 j2 e4 R$ e ax2 = fig.add_subplot(gs[3:5, 1:4])" f: q, M7 o. T; O
ax1.scatter(cps[:, 0], cps[:, 1])% Y$ j( w; P: E: z" g, x! `
ax2.scatter(std_cps[:, 0], std_cps[:, 1])6 N8 i( s1 l" D! T
plt.show() 9 s5 R+ N5 F; U9 Q9 Q% p: U
`
# K) m4 d8 Q4 f; f2 I6 R from sklearn.preprocessing import StandardScaler
% ~8 o" k, @, ?. | from sklearn.preprocessing import MinMaxScaler
5 y& r3 w: C5 f7 W1 | from matplotlib import gridspec
. v9 }& z: a6 \ x. C/ |# ] import numpy as np X& n$ y) q3 ~, @# h: G' v9 R
import matplotlib.pyplot as plt
! s4 O6 ` ^$ ` data = np.random.uniform(0, 100, 10)[:, np.newaxis]
4 q! H A' ]: K8 ^ ss = StandardScaler()
) W( i: B( ?) `+ G std_data = ss.fit_transform(data)1 |4 o( B2 E( U8 T5 g* S
origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据
5 J, B9 F& n( F) N$ ` print(data is 原始数据,data)5 o4 {; ]6 C, }+ ^, J
print(after standard 标准化后的数据,std_data)
0 J% b' ^( [% h6 y) X print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data)/ ]! F9 u; z9 m$ B7 y7 s% ?
print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
* {) o* `/ x5 ~' Z; l 使用sklearn 进行数据的归一化和归一化还原.7 @9 o" }( ~% {
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据 d6 Y, ]" N& y% O4 n
mm = MinMaxScaler()# 创建MinMaxScaler 对象
4 L6 |4 O f$ S$ F* z0 i mm_data = mm.fit_transform(data) # 归一化数据
/ G( a7 _" A5 K, m# ^ origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据' j/ Q* \0 T" d6 k, k6 c& F
print(data is ,data)1 l& f3 ~0 ?8 i+ C0 j" h2 a- @( _
print(after Min Max ,mm_data)' f+ }) L9 W9 V) }: O
print(origin data is ,origin_data) ; {, w: g2 H% K s |: B6 W5 ^
MinMaxScaler和MaxAbsCaler:- Y; D7 O, ~; X2 ^
MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.) % W# x' g! h& Z3 M4 I; z7 I
MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间 + \: `/ Z8 b# M/ C+ \. E- m
min_max_scaler = preprocessing.MinMaxScaler()
! _8 {' Q1 c9 ^* e x_minmax = min_max_scaler.fit_transform(x)1 q9 \. {1 r5 Y" N5 n C& }
x_minmax
) _' W" n" Z/ V) m+ \& r 对于新进来的数据,采用如下方式进行函数调用:
% `6 A# a' B+ q' j% o x_test = np.array([[-3., -1., 4.]])! d9 l9 Z+ [/ P/ ]$ W6 {
x_test_minmax = min_max_scaler.transform(x_test)
- W) u4 M: w/ @5 Q- \ x_test_minmax 3 T. P( y( s/ m G6 y
MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.
9 _" l8 o& O3 ~% @6 } max_abs_scaler = preprocessing.MaxAbsScaler(), N0 R1 _% U2 u
x_train_maxsbs = max_abs_scaler.fit_transform(x)3 U; i* G$ d; G- t" ^
x_train_maxsbs ; Y# P+ I0 y0 |- D9 c, U+ N4 ]4 I
# 同理，也可以对新的数据集进行同样的转换 ' R2 b, D# n, r
x_test = np.array([[-3., -1., 4.]]). s- `1 ]7 q2 T- m4 X
x_test_maxabs = max_abs_scaler.transform(x_test)8 R0 E& G# E' n$ L" ?4 d% D3 w: o
x_test_maxabs
* T6 N# {* Y/ X- p; w 针对规模化稀疏数据' A: t+ V4 T' i+ S2 W" h9 {
对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理: " _+ b1 `9 ]& p5 v: V1 X
MaxAbsScaler,和maxabs_scale 7 o0 G+ r' }* v3 q$ w+ |5 o
针对规模化有异常的数据
0 @2 z. @7 g K2 i 数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.
8 o- V# e: v* H 正则化Normalization* ?$ J f. D" U" @( r8 c7 y' j
正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等 * U$ g \6 p( E2 ] E! h
x_normalized = preprocessing.normalize(x, norm=l2)
4 Y7 P) {, o( Z7 k6 h ]$ | print x# S' e! P! V7 K9 X3 R {
print x_normalized # E: L) q% a' D6 Z; ]) _
# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2) 5 P! Z) p% J* d5 j5 ?
normalizer = preprocessing.Normalizer().fit(x)3 R7 I- G) n# Z4 u6 ^
normalizer
9 y- f |) Q# \) d2 r* u # 对训练数据进行正则 " L* z8 v9 ~! R, x% W0 Q0 t
normalizer.transform(x)
' v8 S) {. ~6 G& J4 S, q # 对新的测试数据进行正则 " T4 H; z. q( M3 V; `" i& [* Y2 K
normalizer.transform([[-1., 1., 0.]])
; Y$ x) F' Y. \* G+ X 二值化9 k, Y% E+ X; x! `" |$ _
特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值 : r" c# L$ n: [# `' ~9 f! S1 q
from sklearn import preprocessing1 ^* C6 H/ s! |4 S# J+ l0 k
import numpy as np/ ?6 ^8 _! S+ R, s6 M" @- O1 ?
1 m7 g7 h" w4 ^3 J. h+ T0 J$ s4 e
# 创建一组特征数据，每一行表示一个样本，每一列表示一个特征! a% }3 i W, q6 n3 |% X. X
x = np.array([[1., -1., 2.],
" B3 ^9 a9 z& O [2., 0., 0.],
H2 ]4 h$ Q( ^: o [0., 1., -1.]])
0 [# d( U+ k4 [! b- `
- i5 W( Z. G# @# A g binarizer = preprocessing.Binarizer().fit(x)
8 h8 z0 z, }% B( w( y( p2 ]( R& j binarizer.transform(x)8 L* T2 P9 E J8 V
% p3 s: `5 H6 Q0 N! A% y1 _, i1 A
binarizer = preprocessing.Binarizer(threshold=1.5)
% D, K3 K/ z, u# C; R; X/ f1 g binarizer.transform(x) + {- v3 k( J$ F6 F, h7 \
为类别特征编码+ W7 D5 H* f/ a8 V5 j
(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.
- z7 ^7 }) _8 g3 x9 e: J OneHotEncoder
9 h& V3 O9 z, R, d 弥补缺失数据- }. |5 p# n' t
可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现. ( V2 X k1 P: ^* v6 ]3 W
import numpy as np9 e) ^1 k4 s1 N) E# u
from sklearn.preprocessing import Imputer
6 d. [+ o: t7 G6 l% g$ g imp = Imputer(missing_values=NaN, strategy=mean, axis=0)
0 D( K6 {- D, i' I imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]])
2 x& {. a( G$ [9 {2 g3 J x = [[np.nan, 2], [6, np.nan], [7, 6]]2 I/ {+ _+ l/ g6 `; i* |
imp.transform(x) & E' j# g* T5 v" J! T3 C! K
Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值，为其补上均值 ' W" |+ A+ _& y+ |9 L
import scipy.sparse as sp
; `# o8 _5 D( ~9 E # 创建一个稀疏矩阵3 R' [. f/ s0 }, n* j* M4 @
x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]]). Y1 T2 f7 W/ J, b, W
imp = Imputer(missing_values=0, strategy=mean, verbose=0)
# @# P1 [- c' P: Y7 ^5 j imp.fit domain name is for sale. Inquire now.(x)
2 T$ ?+ i* N7 U* T" W& S7 @ x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])3 r' }* x9 E8 E Z* b" q, [8 N
imp.transform(x_test) # @: ]$ H- I) O) ~
当我们拿到一批原始的数据
) |1 s: N) S2 ?+ m8 G 首先要明确有多少特征，哪些是连续的，哪些是类别的。 6 z$ V" s ^- h( V/ C0 _
检查有没有缺失值，对确实的特征选择恰当方式进行弥补，使数据完整。 g- G T" t% H" {% a
对连续的数值型特征进行标准化，使得均值为0，方差为1。
7 L4 b# D1 y+ a' b5 y* o% G T# z 对类别型的特征进行one-hot编码。 ) e; t9 H0 x, N# l6 Y0 @& L
将需要转换成类别型数据的连续型数据进行二值化。 4 Y' ^% e1 @0 F+ k3 v0 J: a* a
为防止过拟合或者其他原因，选择是否要将数据进行正则化。
4 q* c+ M; K1 B1 B+ o9 [3 x! c7 V 在对数据进行初探之后发现效果不佳，可以尝试使用多项式方法，寻找非线性的关系。
6 ^! x* b- W' z0 V# w 根据实际问题分析是否需要对特征进行相应的函数转换。 ( c& x4 N5 A( U. ^/ \* I
标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点
' d- ]5 D" }1 p2 C7 i 因此针对动态的数据可以采用如下几种计算方法: 3 C* J1 c$ P' ~( \! A# J
1.arctan反正切函数标准化. http://2.in函数标准化预处理数据的方法总结（使用sklearn-preprocessing）_【人工智能】王小草的博客-CSDN博客
" {6 |/ |- z4 v, q: {- F
. x$ L, N: u/ {8 z9 T8 D* P& ]" l" l7 T& q5 X5 @+ f$ \
9 e5 P: F! G8 S A( {" L& @/ c, y6 S, |; W0 q
|
