现实生活中的数据极易收到噪声、缺失值和不一致数据的影响。数据预处理是数据挖掘过程中的第一个步骤,主要有数据清洗、数据集成、数据归约和数据变换等方式。
数据的质量决定了数据挖掘的效果。而在原始数据中,大多数据都是Dirty
数据,他们存在以下几个方面的问题。
那,既然数据如此重要,我们就需要一套体系来评估数据的好坏不是吗
1️⃣ 准确性
数据记录是否存在异常或者误差
2️⃣ 一致性
数据是否符合某一规则
3️⃣ 完整性
是否存在确实
4️⃣ 时效性
能否及时更新
5️⃣ 可信性
用户可以信赖的数据
6️⃣ 可解释性
是否易于理解
1️⃣ 缺失值处理
2️⃣ 噪声数据处理
1️⃣ 检测与处理缺失值
检测非空值
.isnull()
统计非空值
.isnull().sum()
查看非空值
df.info()
2️⃣ 缺失值处理
️ 删除
dropna()
dropna()
对于Series
,会返回一个仅含非空数据和索引的Series
,而对于一个DataFrame
对象,则会默认丢弃任何含有缺失值的行。
参数 | 说明 |
---|---|
axis | 0是行 1是列 |
how | 确认缺失值的个数,'any’表示只要有缺失值就丢了,'all’则要全部 |
thresh | 可以确定缺失值阈值 |
subset | 只对子列进行操作,例如subset=[‘a’,'b] |
inplace | 不返回 |
️ 填充
fillna()
参数 | 说明 |
---|---|
value | 用于填充缺失值的标量值或者字典对象 |
method | 插值方法 |
axis | 待填充的轴 |
inplace | 原地修改 |
limit | 可以连续填充的最大数量 |
举个栗子
fillna()
可以通过字典的方式进行填充。
df=pd.DataFrame(np.random.randn(5,3))
df.iloc[:3,1:]=pd.NA
print(df)
print(df.fillna({1:0.1,2:0.2}))
0 1 2
0 0.078301 <NA> <NA>
1 1.310107 <NA> <NA>
2 0.025339 <NA> <NA>
3 0.011049 -0.053258 -0.259365
4 0.664727 0.023836 -2.092003
0 1 2
0 0.078301 0.100000 0.200000
1 1.310107 0.100000 0.200000
2 0.025339 0.100000 0.200000
3 0.011049 -0.053258 -0.259365
4 0.664727 0.023836 -2.092003
使用均值填充:
data.fillna(data.mean())
3️⃣ 数据值替换
通过relpace()
方法进行替换
data={'姓名':['张三','小明','马芳','国志'],'性别':['0','1','0','1'],
'籍贯':['北京','甘肃','','上海']}
df=pd.DataFrame(data)
df=df.replace('','我是你爹')
print(df)
姓名 性别 籍贯
0 张三 0 北京
1 小明 1 甘肃
2 马芳 0 我是你爹
3 国志 1 上海
当然,也可以通过传入列表
的方式进行多列更改:
df=df.replace(["我是你爹","北京"],["北京","PK"])
print(df)
哦提一嘴,这里需要接收!!
姓名 性别 籍贯
0 张三 0 PK
1 小明 1 甘肃
2 马芳 0 北京
3 国志 1 上海
不难发现,第一个列表是需要替换的值,第二个列表是替换后的值,且他们之间是并行的!不能链式替换~
也可以通过字典实现多值替换
df=df.replace({"1":"男","0":'女'})
print(df)
姓名 性别 籍贯
0 张三 女 PK
1 小明 男 甘肃
2 马芳 女 北京
3 国志 男 上海
通过自定义函数map
实现~!
data={'姓名':['张三','小明','马芳','国志'],'性别':['0','1','0','1'],
'籍贯':['北京','甘肃','','上海']}
df=pd.DataFrame(data)
df['成绩']=[58,62,71,99]
def grade(x):
if x>=90:
return "优"
if x>=80:
return "良"
if x>=60:
return "及格"
else:
return "不及格"
df['成绩']=df['成绩'].map(grade)
print(df)
姓名 性别 籍贯 成绩
0 张三 0 北京 不及格
1 小明 1 甘肃 及格
2 马芳 0 及格
3 国志 1 上海 优
4️⃣ 异常值检测
散点图
wdf=pd.DataFrame(np.arange(20),columns=['W'])
wdf['Y']=wdf['W']*1.5+2
wdf.iloc[3,1]=128
wdf.iloc[18,1]=150
wdf.plot(kind='scatter',x='W',y='Y')
plt.show()
箱线图
plt.boxplot(wdf['Y'].values,notch=True)
plt.show()
3 σ \sigma σ法则
数据服从正态分布时,在 3 σ 3\sigma 3σ法则下,异常值被定义为一组测定值中与均值偏差超过三倍标准差 σ \sigma σ的值。因为在正态分布下,距离均值 3 σ 3\sigma 3σ之外的值出现的概率小于 0.003 0.003 0.003,可看做小概率时间。
def outRange(S):
blidx=(S.mean()-3*S.std()>S)|(S.mean()+3*S.std()<S)
idx=np.arange(S.shape[0])[blidx]
outRange=S.iloc[idx]
return outRange
print(outRange(wdf['Y']))
18 150.0
Name: Y, dtype: float64
值得注意的是啊,像这种表达式
S.mean()-S.std()>S
会返回有个只有True
或者False
的Series
,也就是0,1
。此时可以用位运算|
保留1
的结果。
但是拿到了Series
,我们还要原始数据呐不是,所以还需要获取原始数据
idx=np.arange(S.shape[0])[blidx]
S.iloc[idx]
有时候需要挖掘的数据可能来自多个数据源,导致数据存在冗余与不一致的情况。数据集成是将多个数据源中的数据合并,并存放到一个一致的数据存储中。
1️⃣ 数据冗余和相关性分析
冗余是数据继承的重要问题,如果一个属性能由另一个属性或者另一组属性值推导而出,那么这个属性可能就是冗余的哦。此外,属性命名不一致也会导致冗余。
我们下面介绍如何判断属性是不是冗余的哈!
χ 2 \chi^2 χ2检验
卡方检验适用于标称属性,假设对于两个属性 A , B A,B A,B, A A A有 c c c个不同的取值, B B B有 r r r个不同的取值,用 A A A和 B B B描述的数据元组可以用一个相依表显示,其中 A A A的 c c c个值构成列, B B B的 r r r个值构成行。 ( A i , B j ) (A_i,B_j) (Ai,Bj)表示属性 A A A取 i i i,属性 B B B取 j j j的联合事件。
χ 2 = ∑ i = 1 c ∑ j = 1 c ( o i j − e i j ) 2 e i j \chi^2=\sum_{i=1}^c\sum_{j=1}^c\frac{(o_{ij}-e_{ij})^2}{e_{ij}} χ2=i=1∑cj=1∑ceij(oij−eij)2
其中 O i j O_{ij} Oij表示联合事件的观测频度, e i j e_{ij} eij表示期望频度,计算式为:
e i j = c o u n t ( A = a i ) × c o u n t ( B = b j ) n e_{ij}=\frac{count(A=a_i)\times count(B=b_j)}{n} eij=ncount(A=ai)×count(B=bj)
n n n为元组个数。
相关系数
又称为皮尔逊矩阵系数(Pearson),相关系数 r A , B r_{A,B} rA,B可定义为:
r A , B = ∑ 1 n ( a i − A ˉ ) ( b i − B ˉ ) n σ A σ B = ∑ 1 n ( a i b j ) − n A ˉ B ˉ n σ A σ B r_{A,B}=\frac{\sum_1^n(a_i-\bar{A})(b_i-\bar{B})}{n\sigma_A\sigma_B}=\frac{\sum_1^n(a_ib_j)-n\bar{A}\bar{B}}{n\sigma_A\sigma_B} rA,B=nσAσB∑1n(ai−Aˉ)(bi−Bˉ)=nσAσB∑1n(aibj)−nAˉBˉ
其中 n n n为元组个数, A ˉ \bar{A} Aˉ为均值, σ \sigma σ为标准差, a i , b i a_i,b_i ai,bi为元组 i i i在 A B AB AB上的取值。
若 A B AB AB独立,则 r A , B = 0 r_{A,B}=0 rA,B=0,取值范围为 − 1 , 1 -1,1 −1,1
协方差
C o v ( X , Y ) = E [ ( X − E ( X ) ) ( Y − E ( Y ) ) ] = E ( X Y ) − E ( X ) E ( Y ) Cov(X,Y)=E[(X-E(X))(Y-E(Y))]=E(XY)-E(X)E(Y) Cov(X,Y)=E[(X−E(X))(Y−E(Y))]=E(XY)−E(X)E(Y)
实现
df.A.cov(df.B)
df.A.corr(df.B)
协方差反映二者趋势程度,取值没有界定,而相关系数则是将其标准化后评估趋近程度,具有取值界定。
2️⃣ 基于Pandas进行数据合并
merge()
例如
pd.merge(a,b,left_on="fruit",right_on="green",how="left")
在合并过程中可能或出现重复列名,我们可以通过suffixes
进行修改
pd.merge(left,right,on="key1",suffixes=('_left','_right'))
concat()
例如
pd.concat([data1,data2],axis=0,join="inner",sort="False")
如果需要合并的两个DF存在重复索引,那么前面两个函数将无法正确合并,我们可以使用combine_first()
进行合并,该方法会优先考虑第一个值。
由于量纲的问题,不同特征之间可能会产生较大的影响。为此,往往需要对数据进行标准化处理。
1️⃣ 离差标准化
做一个简单的线性变化,将数据映射到 [ 0 , 1 ] [0,1] [0,1]
x 1 = x − m i n m a x − m i n x_1=\frac{x-min}{max-min} x1=max−minx−min
2️⃣ 标准差标准化
又称零均值标准化或 z z z分数标准化,处理后的均值为 0 0 0,标准差为 1 1 1
x 1 = x − m e a n s t d x_1=\frac{x-mean}{std} x1=stdx−mean
Data Reduction是指在尽可能保证数据完整性的基础上得到数据的归约表示。也就是说,在归约后的数据集上挖掘更加有效,且会产生相同或相似的结果。
1️⃣ 维归约
减少随机变量或属性的个数,常见的方法有:
属性子集选择
通过删除不相关或冗余属性减少数据量,旨在找出最小属性集,使其分布尽可能接近原始分布。
如何选择一个好的子集?穷举是不显示的,所以一般使用压缩空间的启发式算法进行最优子集选取。
基本的启发式算法包含以下技术:
小波变换
这玩意继承和发展了短时傅里叶变换局部化的思想,又克服了窗口大小不随频率变化等缺点。能提供一个随频率改变的时间-频率窗口,是进行信号时频分析和处理的理想工具。
一般在频域,信号能量主要集中在低频,可以截取中低频系数保留近似的压缩数据。
主成分分析
PCA搜索 k k k个最能代表数据的 n n n维正交向量,是最常使用将为方法。
核心思想是找到数据里最主要的方面代替原始数据。
步骤
尝试
对鸢尾花数据集进行降维
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris
data=load_iris()
y,x=data.target,data.data
pca=PCA(n_components=2)
reduced_x=pca.fit_transform(x)
# 绘出降维后的样本点分布
red_x,red_y=[],[]
blue_x,blue_y=[],[]
green_x,green_y=[],[]
for i in range(len(reduced_x)):
if y[i]==0:
red_x.append(reduced_x[i][0])
red_y.append(reduced_x[i][1])
elif y[i]==1:
blue_x.append(reduced_x[i][0])
blue_y.append(reduced_x[i][1])
else:
green_x.append(reduced_x[i][0])
green_y.append(reduced_x[i][1])
plt.scatter(red_x,red_y,c='r',marker='X')
plt.scatter(blue_x,blue_y,c='b',marker='D')
plt.scatter(green_x,green_y,c='g',marker='.')
plt.show()
2️⃣ 数量归约
用较小、替代的数据表示原始数据。
数据变换是一种将原始数据变化为比较合适的数据格式的方法,以便作为数据处理前特定数据挖掘算法的输入。
数据离散化则是一种数据变化的形式。
1️⃣ 光滑
2️⃣ 属性构造
3️⃣ 聚集
4️⃣规范化
5️⃣ 离散化
用于将概念标签递归组织成更高层的概念,形成数值属性的概念分层,以便不同用户需要
1️⃣ 数据规范化
import pandas as pd
import numpy as np
a=[47,83,81,18,72,41]
b=[56,96,84,21,87,67]
data=np.array([a,b]).T
df=pd.DataFrame(data,columns=["A","B"])
print("离差标准化: ",(df-df.min())/(df.max()-df.min()))
print("标准差标准化: ",(df-df.mean())/df.std())
离差标准化: A B
0 0.446154 0.466667
1 1.000000 1.000000
2 0.969231 0.840000
3 0.000000 0.000000
4 0.830769 0.880000
5 0.353846 0.613333
标准差标准化: A B
0 -0.386103 -0.456223
1 1.003868 1.003690
2 0.926648 0.565716
3 -1.505803 -1.733646
4 0.579155 0.675209
5 -0.617765 -0.054747
2️⃣ 哑变量处理
pd.get_dummies(df)
3️⃣ 连续变量的离散化
等宽法
pd.cut(x,bins,right=True,labels=None,retbins=False,precision=3)
举个栗子
np.random.seed(666)
score_list=np.random.randint(25,100,size=10)
print("原始数据",score_list)
bins=[0,59,70,80,100]
score_cut=pd.cut(score_list,bins)
print(pd.value_counts(score_cut))
c=pd.get_dummies(score_cut)
print(c)
原始数据 [27 70 55 87 95 98 55 61 86 76]
(80, 100] 4
(0, 59] 3
(59, 70] 2
(70, 80] 1
dtype: int64
(0, 59] (59, 70] (70, 80] (80, 100]
0 1 0 0 0
1 0 1 0 0
2 1 0 0 0
3 0 0 0 1
4 0 0 0 1
5 0 0 0 1
6 1 0 0 0
7 0 1 0 0
8 0 0 0 1
9 0 0 1 0
等频法
def SameRateCut(data,k=2):
w=data.quantile(np.arange(0,1+1.0/k,1.0/k))
data=pd.cut(data.w)
return data
简单介绍一下这个方法啊,quantile
表示返回指定位置 q q q的百分位数,通过这个方法生成等频率。
聚类分析法
简单来说,有两步:
1️⃣ 数据标准化与缩放
这边有一个api
sklearn.preprocessing.scale(X,axis=0,with_mean=True,with_std=True,copy=True)
实际作用
import sklearn.preprocessing as pre
import numpy as np
x_train=np.array([[1.,-2.,1.5],[2.2,1.3,0.5],[0.3,1.,-1.5]])
x_scaled=pre.scale(x_train)
print("均值: ",x_scaled.mean(axis=0))
print("标准差: ",x_scaled.std(axis=0))
均值: [0. 0. 0.]
标准差: [1. 1. 1.]
此外,pre模块还提供了一个实用程序类StandardScaler
,可以记录训练时的参数,以便进行相同的转换。
scale=pre.StandardScaler().fit(x_train)
scale.transform(x_test)
2️⃣ 特征缩放
这里介绍三个API
pre.MinMaxScaler() # 范围为[0,1]
pre.MaxAbsScaler() # 范围为[-1,1]
pre.RobustScaler() # 适用于异常值较多
3️⃣ 非线性变换
非线性变换分为分位数变换和幂变换。二者都能保证每个特征值的秩。分位数变换将所有特征置于相同的期望分布中,而幂变换则是将数据从任意分布映射到接近高斯分布的位置。
映射到[0,1]均匀分布
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
import matplotlib.pyplot as plt
X,y=load_iris(return_X_y=True)
X_train,X_test,Y_train,Y_test=train_test_split(X,y,random_state=0)
# 分位数变换
quantile_transformer=preprocessing.QuantileTransformer(random_state=0)
X_train_trans=quantile_transformer.fit(X_train)
X_test_trans=quantile_transformer.transform(X_test)
# 查看分布
fig,ax=plt.subplots(1,2)
ax[0].hist(X_test_trans)
ax[1].hist(X_train)
plt.show()
映射到高斯分布
高斯分布具有稳定的方差和最小化偏度,PowerTransformer
提供了两种幂变换:Yeo-Johnson
和Box-Cox
变换,Box-Cox
仅可用于严格的政数局,这两种变换均通过lambda
进行参数化,通过最大似然进行估计。
pt=preprocessing.PowerTransformer(method='box-cox',standardize=False)
X_lognormal=np.random.RandomState(616).lognormal(size=(300,30))
fig,ax=plt.subplots(1,2)
ax[0].hist(X_lognormal)
T=pt.fit_transform(X_lognormal)
ax[1].hist(T)
plt.show()
映射到正态分布
这里我们调用QuantileTransformer(output_distribution="normal")
pt=preprocessing.QuantileTransformer(output_distribution="normal")
X_lognormal=np.random.RandomState(616).lognormal(size=(300,30))
fig,ax=plt.subplots(1,2)
ax[0].hist(X_lognormal)
T=pt.fit_transform(X_lognormal)
ax[1].hist(T)
plt.show()
4️⃣ 正则化
正则化是将单个样本缩放到单位范数中(每个样本范数为1),如果计划使用点积或者其他核的二次形式量化任意一堆样本的相似性,此过程可能会很有用。通常使用于文本分类和聚类中。
m a k e ∣ ∣ a ∣ ∣ = 1 make\ ||a||=1 make ∣∣a∣∣=1
x=[[1.,-1.,2.],[2.,0.,0.],[0.,1.,-1.]]
# l2正则化
x_nor=preprocessing.normalize(x,norm="l2")
print(x_nor)
[[ 0.40824829 -0.40824829 0.81649658]
[ 1. 0. 0. ]
[ 0. 0.70710678 -0.70710678]]
同样也有一个Normalizer
类,可以通过Transformer
API实现相同操作。
5️⃣ 编码分类特征
如果要把定性数据转化为整数,可以使用OrdinalEncoder
,该估计其可以将每个范畴特征转换为整数的一个新特征。
enc=preprocessing.OrdinalEncoder()
x=[['m','g','17'],['fm','r','22']]
enc.fit(x)
print(enc.transform([['fm','r','17']]))
[[0. 1. 0.]]
除此之外,有个升级版的OneHotEncoder
,这玩意可以将n_categories
转化为一个二进制编码。
enc=preprocessing.OneHotEncoder()
x=[['m','g','17'],['fm','r','22']]
enc.fit(x)
print(enc.transform([['fm','r','17'],['m','g','22']]).toarray())
[[1. 0. 0. 1. 1. 0.]
[0. 1. 1. 0. 0. 1.]]
6️⃣ 离散化
离散化预处理可以将非线性特征引入线性模型中。
K桶离散化
KBinsDiscretizer
将特征离散到K
个桶中
介绍
分桶是离散化的常用方法,将连续型特征离线化为一系列0/1的离散特征。
当数值特征跨越不同的数量级的时候,模型可能只会对大的特征值敏感,这种情况就可以考虑分桶操作。
分桶操作可以看作是对数值变量的离散化,然后通过二值化进行 one hot 编码。
优点
1️⃣分桶后得到的稀疏向量,内积乘法运算速度更快,计算结果更方便存储。
2️⃣对异常数据有很强的鲁棒性。
X = np.array([[-3.,5.,15],[0.,6.,14],[6.,3.,11]])
est = preprocessing.KBinsDiscretizer(n_bins=[3,2,2],encode='ordinal').fit(X)
print(est.transform(X))
[[0. 1. 1.]
[1. 1. 1.]
[2. 0. 0.]]
特征二值化
特征二值化是对数字特征进行于阈值化以获得布尔值的过程。
X = [[1.,-1.,2.],[2.,0.,0.],[0.,1.,-1.]]
binarizer = preprocessing.Binarizer().fit(X)
Y1 = binarizer.transform(X)
print(Y1)
binarizer = preprocessing.Binarizer(threshold=1.1)
Y2 = binarizer.transform(X)
print(Y2)
[[1. 0. 1.]
[1. 0. 0.]
[0. 1. 0.]]
[[0. 0. 1.]
[1. 0. 0.]
[0. 0. 0.]]