数据挖掘：数据清洗——数据噪声处理

一、什么是数据噪声？

数据噪声(Noise)：数据集中的干扰数据（对场景描述不准确的数据），即测量变量中的随机误差或方差。

二、噪声数据与离群点的区别

观测量(Measurement) = 真实数据(True Data) + 噪声 (Noise)：而离群点(Outlier)属于观测量，既有可能是真实数据产生的，也有可能是噪声带来的，但是总的来说是和大部分观测量之间有明显不同的观测值。

数据噪声与离群点有很多相同的地方。之间没有太过明确的定义，主要看应用的场景。如在信用卡诈骗中，我们通常会关注那些少量的异常数据，此时数据是具有探索意义的。而在一般的场景下，离群点和噪声都需要剔除，一般使用的方法也有很多相似之处，如3标准差去噪，dbscan去噪，孤立森林等。

三、产生原因

同异常值，也有机器因素和人为因素。这里不做过多说明。

四、处理的必要性

对模型训练有影响很多算法，不仅会增加数据量，也会加大计算量，增加计算机内存和计算开销，也会增大计算误差。特别是线性算法，都是通过迭代来获取最优解的，如果数据中含有大量的噪声数据，将会大大的影响数据的收敛速度，甚至对于训练生成模型的准确也会有很大的副作用。

五、处理方法

常见的噪声数据的处理方法：

1. 人工检查
2. 统计模型；
3. 分箱；
4. 聚类；
5. 回归 。

5.1 人工检查

根据业务和对数据本身的理解，人为的进行数据筛选。

5.2 统计模型

对于正态数据，利用3个标准差原则进行去噪，或使用四分位差进行去噪。
对于偏态数据用分箱则效果更好。

5.3 分箱

分箱方法是一种简单常用的预处理方法，通过考察相邻数据来确定最终值。所谓“分箱”，实际上就是按照属性值划分的子区间，如果一个属性值处于某个子区间范围内，就称把该属性值放进这个子区间所代表的“箱子”内。把待处理的数据（某列属性值）按照一定的规则放进一些箱子中，考察每一个箱子中的数据，采用某种方法分别对各个箱子中的数据进行处理。
在采用分箱技术时，需要确定的两个主要问题就是：

1. 如何分箱
2. 如何对每个箱子中的数据进行平滑处理。

分箱的方法有4种：等深分箱法、等宽分箱法、用户自定义区间法和最小熵法。

等宽分箱法容易受异常值影响，分箱后可能有的区域值很多，有的很少。分配不均匀。

等深/等频分箱法则容易将相同的值分到不同的箱中。

5.3.1 分箱方法

例：客户收入属性income排序后的值（人民币元）：800 1000 1200 1500 1500 1800 2000 2300 2500 2800 3000 3500 4000 4500 4800 5000。

5.3.1.1 统一权重

也称等深分箱法，将数据集按记录行数分箱，每箱具有相同的记录数，每箱记录数称为箱子的深度。这是最简单的一种分箱方法。每个箱子的深度(箱内数据的个数)统一。

统一权重：设定权重（箱子深度）为4，分箱后

箱1：800 1000 1200 1500

箱2：1500 1800 2000 2300

箱3：2500 2800 3000 3500

箱4：4000 4500 4800 5000

5.3.1.2 统一区间

也称等宽分箱法，使数据集在整个属性值的区间上平均分布，即每个箱的区间范围是一个常量，称为箱子宽度。

统一区间：设定区间范围（箱子宽度）为1000元人民币，分箱后

箱1：800 1000 1200 1500 1500 1800

箱2：2000 2300 2500 2800 3000

箱3：3500 4000 4500

箱4：4800 5000

5.3.1.3 用户自定义区间

用户可以根据需要自定义区间，当用户明确希望观察某些区间范围内的数据分布时，使用这种方法可以方便地帮助用户达到目的。
用户自定义：如将客户收入划分为1000元以下、1000-2000、2000-3000、3000-4000和4000元以上几组，分箱后

箱1：800

箱2：1000 1200 1500 1500 1800 2000

箱3：2300 2500 2800 3000

箱4：3500 4000

箱5：4500 4800 5000

5.3.1.4 最小熵法

熵是不确定性的度量，最大熵原理的意思就是说我们在对结果进行推测时，要承认我们的无知，所以要最大化不确定性，以得到最客观的结果。而对于最小熵原理，则是要最小化每个分箱内的不确定性。跟下面介绍的聚类方法不一样，这里的无监督模型，是为了更好的分组，进而进行数据平滑处理。而后面的聚类是直接把噪声数据删除。
链接：最小熵原理

5.3.2 数据平滑方法

数据平滑方法又可以细分为：平均值平滑、边界值平滑和按中值平滑。
排序后的数据：4, 8, 9, 15, 21, 21, 24, 25, 26, 28, 29, 34。以下例子按照等深分箱处理。

5.3.2.1 平均值平滑

对同一箱值中的数据求平均值，用平均值替代该箱子中的所有数据。

5.3.2.2 边界值平滑

用距离较小的边界值替代箱中每一数据。

5.3.2.3 中值平滑

取箱子的中值，用来替代箱子中的所有数据。

5.4 聚类

可以通过如聚类如k-means来检测离群点。聚类将类似的值组织成群或“簇”。那些落在簇之外的值（孤立点），这些孤立点被视为噪声。同离群点的处理方式。
k均值聚类法将观测值聚为k类，但在聚类过程中需要保证分箱的有序性：第一个分箱中所有观测值都要小于第二个分箱中的观测值，第二个分箱中所有观测值都要小于第三个分箱中的观测值，等等。

5.5 回归

可以用一个函数拟合数据来光滑数据。这种技术称之为回归。即让数据适合一个函数来平滑数据，通过建立数学模型来预测下一个数值。通过，包括线性回归和非线性回归。

1. 线性回归涉及找出拟合两个属性(或变量)的“最佳”直线，使得一个属性可以用来预测另一个。
2. 多元线性回归是线性回归的扩充，其中涉及的属性多余两个，并且数据拟合到一个多维曲面。

六、利用Python进行数据离散化

pandas中的cut(),qcut()用来把一组数据分割成离散的区间。

6.1 使用pd.cut()

pd.cut()，按照数据值的大小（从最大值到最小值进行等距划分）进行划分。每个间隔段里的间隔区间都是相同的，统一区间。

pandas.cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False, duplicates='raise')

• 参数含义
  补充：duplicates：是否允许重复区间。有两种选择：raise：不允许，drop：允许。
  
• 返回值
  out：一个pandas.Categorical, Series或者ndarray类型的值，代表分区后x中的每个值在哪个bin（区间）中，如果指定了labels，则返回对应的label。
  bins：分隔后的区间，当指定retbins为True时返回。

import numpy as np
import pandas as pd

ages = np.array([1,5,10,40,36,12,58,62,77,89,100,18,20,25,30,32]) #年龄数据

# 将ages平分成5个区间，等宽分箱
pd.cut(ages, 5)
[(0.901, 20.8], (0.901, 20.8], (0.901, 20.8], (20.8, 40.6], (20.8, 40.6], ..., (0.901, 20.8], (0.901, 20.8], (20.8, 40.6], (20.8, 40.6], (20.8, 40.6]]
Length: 16
Categories (5, interval[float64]): [(0.901, 20.8] < (20.8, 40.6] < (40.6, 60.4] < (60.4, 80.2] < (80.2, 100.0]]

#将ages平分成5个区间并指定labels
pd.cut(ages, 5, labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])
[婴儿, 婴儿, 婴儿, 青年, 青年, ..., 婴儿, 婴儿, 青年, 青年, 青年]
Length: 16
Categories (5, object): [婴儿 < 青年 < 中年 < 壮年 < 老年]

# 给ages指定区间进行分割
pd.cut(ages, [0,5,20,30,50,100], labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])
[婴儿, 婴儿, 青年, 壮年, 壮年, ..., 青年, 青年, 中年, 中年, 壮年]
Length: 16
Categories (5, object): [婴儿 < 青年 < 中年 < 壮年 < 老年]

#返回分割后的bins,令retbins=True即可
pd.cut(ages, [0,5,20,30,50,100], labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"],retbins=True)
([婴儿, 婴儿, 青年, 壮年, 壮年, ..., 青年, 青年, 中年, 中年, 壮年]
 Length: 16
 Categories (5, object): [婴儿 < 青年 < 中年 < 壮年 < 老年],
 array([  0,   5,  20,  30,  50, 100]))

#只返回x中的数据在哪个bin,令labels=False即可
#第一个0表示1在第0个bin中。
pd.cut(ages, [0,5,20,30,50,100], labels=False)
array([0, 0, 1, 3, 3, 1, 4, 4, 4, 4, 4, 1, 1, 2, 2, 3], dtype=int64)

df_cut['data'] = ages
df_cut['data_分组'] = pd.cut(ages,5)
df_cut['data_标签分组'] = pd.cut(ages,5,labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])
df_cut['data_标签组别'] = pd.cut(ages, [0,5,20,30,50,100], labels=False)

6.2 使用pd.qcut()

pd.qcut()，按照数据出现频率百分比划分，比如要把数据分为四份，则四段分别是数据的0-25%，25%-50%，50%-75%，75%-100%，每个间隔段里的元素个数都是相同的，统一权重。

pd.qcut(x, q, labels=None, retbins=False, precision=3, duplicates='raise') 

# 将ages平分成5个区间
pd.qcut(ages,5)
[(0.999, 12.0], (0.999, 12.0], (0.999, 12.0], (36.0, 62.0], (25.0, 36.0], ..., (12.0, 25.0], (12.0, 25.0], (12.0, 25.0], (25.0, 36.0], (25.0, 36.0]]
Length: 16
Categories (5, interval[float64]): [(0.999, 12.0] < (12.0, 25.0] < (25.0, 36.0] < (36.0, 62.0] < (62.0, 100.0]]

# 查看区间内的数据个数，等深分箱
pd.qcut(ages,5).value_counts()
(0.999, 12.0]    4
(12.0, 25.0]     3
(25.0, 36.0]     3
(36.0, 62.0]     3
(62.0, 100.0]    3
dtype: int64

#将ages平分成5个区间并指定labels
pd.qcut(ages,5,labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])
[婴儿, 婴儿, 婴儿, 壮年, 中年, ..., 青年, 青年, 青年, 中年, 中年]
Length: 16
Categories (5, object): [婴儿 < 青年 < 中年 < 壮年 < 老年]

#返回分割后的bins,令retbins=True即可
pd.qcut(ages,5,labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"],retbins=True)
[婴儿, 婴儿, 婴儿, 壮年, 中年, ..., 青年, 青年, 青年, 中年, 中年]
([婴儿, 婴儿, 婴儿, 壮年, 中年, ..., 青年, 青年, 青年, 中年, 中年]
 Length: 16
 Categories (5, object): [婴儿 < 青年 < 中年 < 壮年 < 老年],
 array([  1.,  12.,  25.,  36.,  62., 100.]))
 
#只返回x中的数据在哪个bin,令labels=False即可
#第一个0表示1在第0个bin中。
pd.cut(ages, 5, labels=False)
array([0, 0, 0, 1, 1, 0, 2, 3, 3, 4, 4, 0, 0, 1, 1, 1], dtype=int64)

df_qcut = pd.DataFrame()
df_qcut['data'] = ages
df_qcut['data_分组'] = pd.qcut(ages,5)
df_qcut['data_标签分组'] = pd.qcut(ages,5,labels=[u"婴儿",u"青年",u"中年",u"壮年",u"老年"])
df_qcut['data_标签组别'] = pd.qcut(ages, 5, labels=False)

七、总结

噪声和离群点之间有一定的差别，而具体的处理要看应用场景是什么。
存在数据噪声，会增大数据量，影响模型运行速度，并对准确率造成影响。
处理方法有

1. 人工检查
2. 统计模型；
3. 分箱；
4. 聚类；
5. 回归 。

对于分箱，可先使用pandas中的cut()和qcut()，进行分箱，然后通过mean(),median()编写数据平滑的函数，作为替代值。具体哪种分箱方式，要看应用的场景。如年龄，等宽分箱比较合理。
聚类和回归可使用sklearn中的包实现。其中回归通过对数据拟合预测的方式，来甄别噪声数据。

八、参考文献

https://blog.csdn.net/M_WBCG/article/details/79117085
https://blog.csdn.net/poi10086/article/details/82497065
https://blog.csdn.net/qq_32572085/article/details/89704051
https://www.zhihu.com/question/37506766
https://www.cnblogs.com/nicetoseeyou/p/10655422.html
https://www.cnblogs.com/sench/p/10128216.html
https://www.cnblogs.com/nicetoseeyou/p/10655422.html

1.噪声是什么？数据集中的干扰数据（对场景描述不准确的数据）

2.噪声怎么产生的？举个例子：手机信号来自于基站发射的电磁波，有的地方比较强，有的地方比较弱。运营商的工程师会负责统计不同区域信号强弱来进行网络规划，工程师采集信号的方法就是将一个信号接受终端固定到车上，然后开车绕着基站转，信号终端就会自动采集不同区域的信号强度，生成一份数据。但是如果车在采集过程中遇到了突发事件、急刹车，就可能会对信号采集造成一定的影响，生成噪声数据。

3.噪声对模型训练有什么影响？很多算法，特别是线性算法，都是通过迭代来获取最优解的，如果数据中含有大量的噪声数据，将会大大的影响数据的收敛速度，甚至对于训练生成模型的准确也会有很大的副作用。

4.去除噪声的方法：根据不同的业务场景有不同的处理方法，这里只提出正态分布3σ原则。正态分布也叫常态分布，是连续随机变量概率分布的一种，自然界、人类社会、心理、教育中大量现象均按正态分布，如能力的高低、学生成绩的好坏都属于正态分布，我们可以把数据集的质量分布立杰成一个正态分布。它会随着随机变量的平均数、标准差与单位不同而有不同的分布形态。正态分布可以表示成一种概率密度函数。

正态分布具有这样的特点：x落在（μ-3σ，μ+3σ）以外的概率小于千分之三。根据这一特点，我们可以通过计算数据集的标准差，把三倍于数据集的标准差的点设想为噪声数据排除。

示例

from __future__ import division

mat = [[19, 26, 63], [13, 62, 65], [16, 69, 15], [14, 56, 17], [19, 6, 15], [11, 42, 15], [18, 58, 36], [12, 77, 33],
       [10, 75, 47], [15, 54, 70], [10017, 1421077, 4169]]


# 获得矩阵的字段数量
def width(lst):
    i = 0;
    for j in lst[0]:
        i += 1
    return i


# 得到每个字段的平均值
def GetAverage(mat):
    n = len(mat)
    m = width(mat)
    num = [0] * m
    for i in range(0, m):
        for j in mat:
            num[i] += j[i]
        num[i] = num[i] / n
    return num


# 获得每个字段的标准差
def GetVar(average, mat):
    ListMat = []
    for i in mat:
        ListMat.append(list(map(lambda x: x[0] - x[1], zip(average, i))))

    n = len(ListMat)
    m = width(ListMat)
    num = [0] * m
    for j in range(0, m):
        for i in ListMat:
            num[j] += i[j] * i[j]
        num[j] /= n
    return num

# 获得每个字段的标准差
def GetStandardDeviation(mat):
    return list(map(lambda x:x**0.5,mat))
# 对数据集去噪声
def DenoisMat(mat):
    average = GetAverage(mat)
    variance = GetVar(average, mat)
    standardDeviation=GetStandardDeviation(variance)
    section = list(map(lambda x: x[0] + 3*x[1], zip(average, standardDeviation)))
    n = len(mat)
    m = width(mat)
    num = [0] * m
    denoisMat = []
    noDenoisMat=[]
    for i in mat:
        for j in range(0, m):
            if i[j] > section[j]:
                denoisMat.append(i)
                break
            if j==(m-1):
                noDenoisMat.append(i)
    print("去除完噪声的数据：")
    print(noDenoisMat)
    print("噪声数据：")
    return denoisMat


if __name__ == '__main__':
    print("初始数据：")
    print(mat)
    print(DenoisMat(mat))