现实生活中的数据极易收到噪声、缺失值和不一致数据的影响。数据预处理是数据挖掘过程中的第一个步骤，主要有数据清洗、数据集成、数据归约和数据变换等方式。
一、数据预处理的必要性
数据的质量决定了数据挖掘的效果。而在原始数据中，大多数据都是 Dirty数据，他们存在以下几个方面的问题。
- 数据不一致
- 噪声数据
- 缺失值
那，既然数据如此重要，我们就需要一套体系来评估数据的好坏不是吗
1️⃣ 准确性
数据记录是否存在异常或者误差
2️⃣ 一致性
数据是否符合某一规则
3️⃣ 完整性
是否存在确实
4️⃣ 时效性
能否及时更新
5️⃣ 可信性
用户可以信赖的数据
6️⃣ 可解释性
是否易于理解
二、数据清洗
2.1 数据清洗方法
1️⃣ 缺失值处理
- 忽略元组
- 人工填写缺失值
- 使用常量填充缺失值
- 使用中心趋势度填充缺失值
- 采用均值或者中位数填充
- 利用最可能的值进行填充
2️⃣ 噪声数据处理
- 分箱–借助邻域来光滑数据值
- 回归–采样函数来拟合光滑数据
- 离去点分析
2.2 基于Pandas进行数据清洗
1️⃣ 检测与处理缺失值
👦 检测非空值
.isnull()
📧 统计非空值
.isnull().sum()
🏁 查看非空值
df.info()
2️⃣ 缺失值处理
🅱️ 删除
dropna()
dropna()对于 Series，会返回一个仅含非空数据和索引的 Series，而对于一个 DataFrame对象，则会默认丢弃任何含有缺失值的行。
参数说明axis0是行 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]
2.3 数据集成
有时候需要挖掘的数据可能来自多个数据源，导致数据存在冗余与不一致的情况。数据集成是将多个数据源中的数据合并，并存放到一个一致的数据存储中。
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)(A i ,B j )表示属性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 ∑c j =1 ∑c e ij (o ij −e ij )2
其中O i j O_{ij}O ij 表示联合事件的观测频度，e i j e_{ij}e ij 表示期望频度，计算式为：
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}e ij =n co u n t (A =a i )×co u n t (B =b j )
n n n为元组个数。
相关系数
又称为皮尔逊矩阵系数(Pearson)，相关系数r A , B r_{A,B}r A ,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}r A ,B =n σA σB ∑1 n (a i −A ˉ)(b i −B ˉ)=n σA σB ∑1 n (a i b j )−n A ˉB ˉ
其中n n n为元组个数，A ˉ \bar{A}A ˉ为均值，σ \sigma σ为标准差，a i , b i a_i,b_i a i ,b i 为元组i i i在A B AB A B上的取值。
若A B AB A B独立，则r A , B = 0 r_{A,B}=0 r A ,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)C o v (X ,Y )=E [(X −E (X ))(Y −E (Y ))]=E (X Y )−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()进行合并，该方法会优先考虑第一个值。
2.4 数据标准化
由于量纲的问题，不同特征之间可能会产生较大的影响。为此，往往需要对数据进行标准化处理。
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}x 1 =ma x −min x −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}x 1 =s t d x −m e an
2.5 数据归约
Data Reduction是指在尽可能保证数据完整性的基础上得到数据的归约表示。也就是说，在归约后的数据集上挖掘更加有效，且会产生相同或相似的结果。
1️⃣ 维归约
减少随机变量或属性的个数，常见的方法有：
- 属性子集选择
- 小波变换
- 主成分分析
属性子集选择
通过删除不相关或冗余属性减少数据量，旨在找出最小属性集，使其分布尽可能接近原始分布。
如何选择一个好的子集？穷举是不显示的，所以一般使用压缩空间的启发式算法进行最优子集选取。
基本的启发式算法包含以下技术：
- 逐步向前选择
- 也就是状态移动
- 逐步向后删除
- 末位淘汰
- 选择+删除
- 混合
- 决策树归纳
小波变换
这玩意继承和发展了短时傅里叶变换局部化的思想，又克服了窗口大小不随频率变化等缺点。能提供一个随频率改变的时间-频率窗口，是进行信号时频分析和处理的理想工具。
一般在频域，信号能量主要集中在低频，可以截取中低频系数保留近似的压缩数据。
主成分分析
PCA搜索k k k个最能代表数据的n n n维正交向量，是最常使用将为方法。
核心思想是找到数据里最主要的方面代替原始数据。
步骤
- 对样本中心化x ( i ) = x ( i ) − 1 m ∑ j = 1 m x ( j ) x(i)=x(i)-\frac{1}{m}\sum_{j=1}^mx(j)x (i )=x (i )−m 1 ∑j =1 m x (j )
- 计算样本的协方差矩阵x x T xx^T x x T
- 对协方差矩阵进行特征分析
- 取出最大的n n n个特征值对应的特征向量( w 1 , w 2 , . . . , w n ) (w_1,w_2,…,w_n)(w 1 ,w 2 ,…,w n )，将所有的特征向量标准化后，组成特征向量矩阵W W W
- 将每个样本通过特征向量矩阵转化为新的样本，并得到样本集z ( i ) = W T x ( i ) z(i)=W^Tx(i)z (i )=W T x (i )
尝试
对鸢尾花数据集进行降维
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️⃣ 数量归约
用较小、替代的数据表示原始数据。
- 回归和对数线性模型
- 直方图
- 积累
- 抽样
- 数据立方体聚类
- 数据压缩
2.6 数据变换与数据离散化
数据变换是一种将原始数据变化为比较合适的数据格式的方法，以便作为数据处理前特定数据挖掘算法的输入。
数据离散化则是一种数据变化的形式。
数据变换的策略
1️⃣ 光滑
2️⃣ 属性构造
3️⃣ 聚集
4️⃣规范化
5️⃣ 离散化
用于将概念标签递归组织成更高层的概念，形成数值属性的概念分层，以便不同用户需要
- 分箱离散化
- 基于指定的箱个数的自顶向下的分裂技术，例如使用等宽或等频分箱，再通过箱均值或者中位数替换箱中的每个值，使得属性值离散化。
- 直方图离散化
- 可以按照规定生成直方图，并且递归调用产生概念级
- 聚类、决策树、相关性分析进行离散化
Python数据变化与离散化
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的百分位数，通过这个方法生成等频率。
聚类分析法
简单来说，有两步：
- 将连续性数据用聚类算法进行聚类，处理聚类得到的簇
- 为合并到一个簇的连续性数据做统一标记
2.7 基于scikit-learn进行数据预处理
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()
pre.MaxAbsScaler()
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 mak e ∣∣a ∣∣=1
x=[[1.,-1.,2.],[2.,0.,0.],[0.,1.,-1.]]
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类，可以通过 TransformerAPI实现相同操作。
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.]]
Original: https://blog.csdn.net/qq_45957458/article/details/127636853
Author: Torture_L
Title: 【数据挖掘】数据预处理
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/741332/
转载文章受原作者版权保护。转载请注明原作者出处！