收藏本站 劰载中...网站公告 | 吾爱海洋论坛交流QQ群:835383472

sklearn Preprocessing 数据预处理

[复制链接]
# W; o& n! [. k" G2 e8 g

sklearn Preprocessing 模块

对数据进行预处理的优点之一就是能够让模型尽快收敛.

标准化和归一化:

7 F, r* S: G$ O- Y; X# d

归一化是标准化的一种方式,

- s+ ]; t& h; L0 P7 s) C

归一化是将数据映射到[0,1]这个区间中,

, ~$ b8 Q x R+ n; \/ ?& _6 \

标准化是将数据按照比例缩放,使之放到一个特定区间中,

" Z% Q9 P+ }1 P3 s

标准化后的数据均值为0,标准差等于1,因而标准化的数据可正可负.

v% c4 ?0 p8 e3 N M: d

如果原始数据不符合高斯分布的话,标准化后的数据效果并不好.(标准化的原因在于如果有些特征的方差过大,则会主导目标函数从而使参数估计器无法正确地去学习其他特征.)

9 E4 _ ?+ H* |( n7 ~

导入模块:

2 J, L$ i/ @7 e# \; z+ p; c3 R* `
from sklearn.preprocessing import StandardScaler. B+ u1 X0 |4 e0 R0 ~2 p" B' F from sklearn.preprocessing import MinMaxScaler ( a' M" l) C3 v! X$ a from matplotlib improt gridspec 6 x6 [+ U8 d) |5 ]. M- n$ a, C" L8 d import numpy as np . U( S3 A* U1 J: j0 c; ] import matpotlib.pyplot as plt
( @) b. t5 d0 ?

使用sklearn 进行标准化和标准化还原

# T- z+ M, A9 T% U9 N/ ^/ Y

标准化的过程分为两步:

去均值的中心化(均值变为0);方差的规模化(方差变为1).将每一列特征标准化为标准正太分布,注意,标准化是针对每一列而言的

x_scale = preprocessing.scale(x)

' w( ~, d& v; ?; H' `7 H8 L' s
std = StandardScaler() : w# M, w# c8 T6 e+ K8 r0 z data = std.fit_transform(data[["RSSI0", "RANGES", "weekday", "hour", "RSS_mean", "RANGES_mean", day_label]])3 C! Z! {' j" R; C) |1 B " q- i- p3 ~; `7 } |' t! a$ K # 将标准化后的数据转换为原始数据。4 Z3 h3 o" V& s2 ?7 V2 h) g* ?1 K std.inverse_transform()
, g. I. W8 t: j8 K

查看标准化后的数据的均值与方差

' k1 `/ c% h, x0 o* Z) P
x_scale.mean(axis=0)# 均值
% `1 w* c; R7 ~. v/ m# _) ~

# axis=1表示对每一行去做这个操作,axis=0表示对每一列做相同的这个操作

; Q8 |1 ]' I0 W8 P. ?: m# A6 m
x_scale.mean(axis=1)
8 g9 b) B: A+ a9 B! w

`

6 H9 I* @4 K, H) }6 ^% `$ L
cps = np.random.random_integers(0, 100, (100, 2)) , C( k6 _. ?' H* H8 e6 H( |! s& h # 创建StandardScaler 对象,再调用fit_transform 方法,传入一个格式的参数数据作为训练集.! y$ K3 m1 \# c# ^$ i ss = StandardScaler() & w0 a5 j/ B) ^" V F3 P! c std_cps = ss.fit_transform(cps) " j. x5 ?0 Z7 R1 @8 q* U' y gs = gridspec.GridSpec(5,5) : K2 I4 }) c& P4 G& M fig = plt.figure()% A2 |, Y) g1 I0 y7 ?) \ ax1 = fig.add_subplot(gs[0:2, 1:4]) - P- m/ C& V" g ax2 = fig.add_subplot(gs[3:5, 1:4]), w- r. L. V+ l% x' x2 f: C ax1.scatter(cps[:, 0], cps[:, 1])8 a3 @' D9 K) z ax2.scatter(std_cps[:, 0], std_cps[:, 1]) : a! B- ~+ F+ Z( G/ B+ g plt.show()
3 D* j4 R4 ^: b# ?

`

1 x9 f0 L! H/ @, [4 b
from sklearn.preprocessing import StandardScaler 0 d5 K& S* x* L from sklearn.preprocessing import MinMaxScaler : m# u8 E. u7 D+ k7 s: [8 P) b from matplotlib import gridspec1 d4 E( O7 v S7 h import numpy as np l( c2 Y1 Z% @( o0 s4 M" \ import matplotlib.pyplot as plt 8 i. L3 N; u+ D& \. q) e data = np.random.uniform(0, 100, 10)[:, np.newaxis]7 k7 Q4 C* X, }& B2 t# } ss = StandardScaler() ( V4 w6 ^$ x. p0 d4 z, S) z: N: a std_data = ss.fit_transform(data)8 d$ c$ L% G- m. n/ W& j origin_data = ss.inverse_transform(std_data) # 得到标准化之前的数据" P3 _' P' m, ^ print(data is 原始数据,data)1 ?* J" _5 z) n9 b3 w print(after standard 标准化后的数据,std_data) - K& Q1 @% E s& A+ V print(after inverse 通过inverse_transform该函数将标准化后的数据转化为原始数据:,origin_data); ?) I g% |1 E9 _) g% ^2 Q) c print(after standard mean and std is 均值mean(均值) 和 标准差std(矩阵标准差),np.mean(std_data), np.std(std_data))
0 d( ~3 P2 j! v: y

使用sklearn 进行数据的归一化和归一化还原.

/ y) S! G7 b$ R6 D& [5 H8 h
data = np.random.uniform(0, 100, 10)[:, np.newaxis] # 创建数据" n- B# i5 m4 K5 G& ~3 Q7 M mm = MinMaxScaler()# 创建MinMaxScaler 对象* o. f& j1 T* X# k mm_data = mm.fit_transform(data) # 归一化数据 9 t4 X! u( c2 W% Z' g origin_data = mm.inverse_transform(mm_data) # 转换成归一化之前的数据2 T9 L4 H3 x/ |/ B1 q print(data is ,data) ' x( C. v$ M) _3 Q% y1 T print(after Min Max ,mm_data)6 A; N3 P9 I) N9 w print(origin data is ,origin_data)
' q2 [6 Q, [- c+ V! i g/ q4 x

MinMaxScaler和MaxAbsCaler:

. N" C7 X) p/ |- @4 m0 ]

MinMaxScaler:使得特征的分布在一个给定的最小值和最大值的范围内.一般情况下载0`1之间(为了对付哪些标准差相当小的特征并保留下稀疏数据中的0值.)

) s# O* }! a- l4 f

MaxAbsScaler:或者是特征中的绝对值最大的那个数为1,其他依次为标准分布在-1`1之间

, Z$ |8 Q3 W% h0 {0 C: M. Y
min_max_scaler = preprocessing.MinMaxScaler()3 q2 B0 [( }7 K0 J x_minmax = min_max_scaler.fit_transform(x) ; w8 x& g4 [' P# Y5 R( Q: H x_minmax
/ j. H( O. y# c- Q' i/ M

对于新进来的数据,采用如下方式进行函数调用:

/ Z: @% q; D% F( a8 W
x_test = np.array([[-3., -1., 4.]]) ) [7 k( W( Y% S9 z; V+ }" ? x_test_minmax = min_max_scaler.transform(x_test)6 f. R: p4 Y: h x_test_minmax
( a- V4 Z+ a5 b4 I0 d/ I+ p

MaxAbsScaler:数据会被规模化到-1`1之间,就是特征中,所有数据都会除以最大值,该方法对哪些已经中心化均值为0,或者稀疏的数据有意义.

% F/ ?* {/ O; C
max_abs_scaler = preprocessing.MaxAbsScaler(); k2 H* @- d1 P( v x_train_maxsbs = max_abs_scaler.fit_transform(x)5 @# c Z! {" w l1 x x_train_maxsbs
5 }6 d0 t$ h" K% }/ I1 N8 h

# 同理,也可以对新的数据集进行同样的转换

8 h4 J* R- `9 Z1 x$ i [
x_test = np.array([[-3., -1., 4.]])" Q0 h* B# e+ F1 g' x x_test_maxabs = max_abs_scaler.transform(x_test) 7 v, _7 T$ ?& p5 k; `/ `2 }4 u6 b x_test_maxabs
& Y) _$ o: d8 N& L

针对规模化稀疏数据

9 j4 C& h) g2 j q) f) K- B2 N

对稀疏数据去均值的中心化会破坏稀疏的数据结构,使用如下两个方法进行处理:

* f# y5 R& P, a- e) R6 q

MaxAbsScaler,和maxabs_scale

x, E3 V7 `( u" R% h( G

针对规模化有异常的数据

1 H* C% q' ]5 W7 y* s8 G

数据集中有很多异常值,就不能使用数据的均值和方差去做标准化了.可以使用robust_scale和RobustScaler ,更具中位数或者四分位数去中心化数据.

+ j1 F; u! Z( m/ J0 Q& \

正则化Normalization

0 L/ Y, F, ^7 X- y, b

正则化是将样本在向量空间模型上的一个转换,常常被使用在分类和聚类中,使用函数normalize实现一个单向量的正则化功能.正则化化有I1,I2等

( G5 A/ X; J$ x' K' ~
x_normalized = preprocessing.normalize(x, norm=l2)# P* m4 h d; _: u! L' Q print x* o. T' Y5 {6 [7 F' r print x_normalized
" t: x, x+ _% ?! U

# 根据训练数据创建一个正则器 Normalizer(copy=True, norm=l2)

0 ~ O9 U( f n6 A4 @2 ]
normalizer = preprocessing.Normalizer().fit(x) ! A# W% a! Q, [& C& i normalizer
& ?, i- y+ K7 y* v- C9 O

# 对训练数据进行正则

* n+ I! J1 Y2 b7 S U1 H
normalizer.transform(x)
' W/ K" v% N& P# D" y3 E4 k: x

# 对新的测试数据进行正则

3 @7 S& L) f/ E
normalizer.transform([[-1., 1., 0.]])
( I8 ?4 c- X( x% u" _- k

二值化

; W0 K" x( s( R/ I

特征的二值化(指将数值型的特征数据转换为布尔类型的值,使用实用类Binarizer),默认是根据0来二值化,大于0的都标记为1,小于等于0的都标记为0.通过设置threshold参数来更改该阈值

" D& y4 T$ S* }& s/ o1 v5 u
from sklearn import preprocessing ) r$ x: L% ^, g% y& o/ l import numpy as np. k3 K3 O/ I9 v # x& k' ~/ C+ Y0 e # 创建一组特征数据,每一行表示一个样本,每一列表示一个特征4 P: m4 J% S" m, x x = np.array([[1., -1., 2.], & a" c5 A, N- \; l [2., 0., 0.], 5 u$ H: K$ [- I4 }; E [0., 1., -1.]])- j9 J2 I7 _$ l! b6 P0 ]% h o# ]! T5 ^7 t( B+ i I binarizer = preprocessing.Binarizer().fit(x) 6 a* _- Y+ Z0 `" O) t7 x7 u: \ binarizer.transform(x)5 @0 a0 m+ R. P& }& W+ k * W% w" S9 X" S. T$ B6 J' D1 w binarizer = preprocessing.Binarizer(threshold=1.5) $ b0 ]3 ~/ l6 v8 r! M, p& K# T- ] binarizer.transform(x)
5 o* R: b5 z, k! A" Q

为类别特征编码

+ s1 I3 j! l" j4 G0 A

(比如性别:male,来自于哪个国家或地区:from US,使用什么浏览器:users Chrome) 可以转换为 013 或者是其他的数值型编码.

8 L' ~& E: z4 x) W& c$ e2 e

OneHotEncoder

+ `7 i0 t+ g! W, @

弥补缺失数据

! r4 H4 H, G% L. x

可以使用均值,中位数,众数等等弥补缺失数据,可以使用Imputer实现.

0 C' @: ]! H# T# |$ {$ n/ v n+ l2 n
import numpy as np. q: s% f' O- O+ _1 `: ~, k from sklearn.preprocessing import Imputer P3 o$ I' b% r/ s1 J imp = Imputer(missing_values=NaN, strategy=mean, axis=0)5 h) _) A; n0 v4 n5 ~2 A imp.fit domain name is for sale. Inquire now.([[1, 2], [np.nan, 3], [7, 6]]) 7 |8 Z; ?8 H F# w, E8 L x = [[np.nan, 2], [6, np.nan], [7, 6]]& o) \- p% r( ]/ L9 p% d ~ imp.transform(x)
; z% T0 u: T) r, |1 @7 v& |: U/ V

Imputer类同样也可以支持稀疏矩阵,以下例子将0作为了缺失值,为其补上均值

9 p: s: I3 { W# `6 w4 D* s
import scipy.sparse as sp% C. ~+ n1 K5 H- K/ a! C # 创建一个稀疏矩阵 - A$ u3 U- r7 S, f& u7 v; a x = sp.csc_matrix([[1, 2], [0, 3], [7, 6]])0 `: d9 ^# N# D9 o# c imp = Imputer(missing_values=0, strategy=mean, verbose=0)1 V$ j1 e# v" o- S imp.fit domain name is for sale. Inquire now.(x) & ~' c9 x) D% P$ P3 V& \. ? x_test = sp.csc_matrix([[0, 2], [6, 0], [7, 6]])3 q- \ o- }" l imp.transform(x_test)
0 k- w5 ]& ?& x& P

当我们拿到一批原始的数据

8 w- }% M! Q2 w

首先要明确有多少特征,哪些是连续的,哪些是类别的。

) O; m$ ~( P* w; v C! ~) y1 Z

检查有没有缺失值,对确实的特征选择恰当方式进行弥补,使数据完整。

2 q5 ]9 F% B( m" [/ H0 s

对连续的数值型特征进行标准化,使得均值为0,方差为1。

( x8 j* y; S* T' [: T: Q

对类别型的特征进行one-hot编码。

/ x n- ?! R+ G

将需要转换成类别型数据的连续型数据进行二值化。

/ d1 G- s% ]8 p2 [5 b5 x" m

为防止过拟合或者其他原因,选择是否要将数据进行正则化。

* Q% `9 `5 [! x; u* ^* A1 c( f

在对数据进行初探之后发现效果不佳,可以尝试使用多项式方法,寻找非线性的关系。

: @& K. V) N ]- @ a

根据实际问题分析是否需要对特征进行相应的函数转换。

6 S( a7 {, z4 ^ i \8 {- u8 H0 W

标准化和归一化的缺点:每当有新的数据进来时,就要重新计算所有的点

6 U) v( A3 o8 ^6 m

因此针对动态的数据可以采用如下几种计算方法:

: o2 H# W) G, V2 T( D |- V/ d

1.arctan反正切函数标准化.

http://2.in函数标准化

预处理数据的方法总结(使用sklearn-preprocessing)_【人工智能】王小草的博客-CSDN博客

x' Y# k3 r1 i! |& C. F6 R, \ G: i; M 3 b" X6 S# d# B1 u4 R/ I( a$ U8 f) w0 \) y, L , N- B. M& Z# n. ~ 3 X! M; h& j5 R& p9 D: J6 i. [
回复

举报 使用道具

相关帖子

全部回帖
暂无回帖,快来参与回复吧
懒得打字?点击右侧快捷回复 【吾爱海洋论坛发文有奖】
您需要登录后才可以回帖 登录 | 立即注册
天阶雨
活跃在2026-3-29
快速回复 返回顶部 返回列表