《数据挖掘概念与技术》学习笔记-第三章

3.1数据质量可以从多方面评估，包括准确性、完整性和一致性问题。对于以上每个问题，讨论数据质量的评估如何依赖于数据的应用目的，给出例子。提出数据质量的两个其他尺度。

对于数据准确性，以商场业务为例。在顾客地址数据库中，有些地址已经过时或不正确，但还有80%的地址是正确的。对于市场分析人员，考虑到对目标市场的营销，这是一个大型顾客数据库，因此对数据的准确性还算满意。而对于特定的客户经理，当考虑某个客户的地址信息时，这个数据就是不正确的。
对于数据完整性，以耐药性数据库为例。在耐药性数据库中，可能存在某些月份的药敏检测数据缺失的情况。如果这些数据用于分析耐药性在长时间段上的整体趋势，那么某个月份的数据缺失并不造成影响，数据集的完整性是满足要求的。如果这些数据用于生成相关的详细报表，其完整性就无法令人满意。
对于数据一致性。数据库中某两个表中可能存在两个属性含义相同，名称却不同。对于计算机来说，不同的属性名称是不一致的，在数据库的批量处理中造成较大的困难。但对于日常数据阅读和应用，这两个属性的名称可能是易于辨认的，其表达的不一致并不对应用造成影响，因此可以认为一致性是满足要求的。
时效性、可信性和可解释性。

3.2在现实世界的数据中，某些属性上缺失值的元组是比较常见的。讨论处理这一问题的方法。

有以下方法：忽略元组，人工填写缺失值，使用一个全局常量填充缺失值，使用属性的中心度量（如均值或中位数）填充缺失值，使用于给定元组属同一类的所有样本的属性均值或中位数，使用最可能的值填充缺失值。

3.3在习题2.2中，属性age包括如下值（以递增序）：13，15，16，16，19，20，20，21，22，22，25，25，25，25，30，33，33，35，35，35，35，36，40，45，46，52，70。

（a）使用深度为3的箱，用箱均值光滑以上数据。说明你的步骤，讨论这种技术对给定数据的效果。

划分为箱：
箱1：13，15，16
箱2：16，19，20
箱3：20，21，22
箱4：22，25，25
箱5：25，25，30
箱6：33，33，35
箱7：35，35，35
箱8：36，40，45
箱9：46，52，70
用箱均值光滑：
箱1：14.67，14.67，14.67
箱2：18.33，18.33，18.33
箱3：21，21，21
箱4：24，24，24
箱5：26.67，26.67，26.67
箱6：33.67，33.67，33.67
箱7：35，35，35
箱8：40.33，40.33，40.33
箱9：56，56，56
这种方法可以有效地去除数据中的噪声，但对数据点的改变导致每个数据的含义发生了变化，可能会与数据本身偏离。

（b）如何确定该数据中的离群点？

可以通过聚类来检测离群点。

（c）还有什么其他方法来光滑数据？

箱边界光滑、回归。

3.4讨论数据集成需要考虑的问题。

实体识别问题：来自多个信息源的现实世界的等价实体如何才能“匹配”。在集成期间，当一个数据库的属性与另一个数据库的属性匹配时，必须特别注意数据的结构。
冗余问题：一个属性如果能由另一个或另一组属性“导出”，则这个属性可能时冗余的。属性或维命名的不一致也可能导致结果数据集中的冗余。有些冗余可以被相关分析检测到。给定两个属性，这种分析可以根据可用的数据，度量一个属性能在多大程度上蕴涵另一个。对于标称数据，使用${\chi }^2$检验。对数值属性，使用相关系数和协方差，它们都评估一个属性的值如何随另一个变化。
元组重复：对于给定的唯一数据实体，存在两个或多个相同的元组。去规范化表的使用是数据冗余的另一个来源。不一致通常出现在各种不同的副本之间，由于不正确的数据输入，或者由于更新了数据的某些出现，但未更新所有的出现。
数据值冲突的检测与处理：对于现实世界的同于实体，来自不同数据源的属性值可能不同。这可能是因为表示、尺度或编码不同。属性也可能在不同的抽象层，其中属性在一个系统中记录的抽象层可能比另一个系统中“相同的”属性低。

3.5如下规范化方法的值域是什么？

（a）最小-最大规范化。

人为设定的最小-最大区间，例如$[0.0,1.0]$。

（b）z分数规范化。

$$[\frac{v_{min}-\bar{A}}{{\sigma }_A},\frac{v_{max}-\bar{A}}{{\sigma }_A}]$$其中，$\bar{A}$和${\sigma }_A$分别是属性A的均值和标准差。

（c）z分数规范化，使用均值绝对偏差而不是标准差

$$[\frac{v_{min}-\bar{A}}{s_A},\frac{v_{max}-\bar{A}}{s_A}]$$其中，$s_A$是A的均值绝对偏差（mean absolute deviation）。

（d）小数定标规范化

$$[\frac{v_{min}}{10^j},\frac{v_{max}}{10^j}]$$其中，j是使得$max（|v_i^{\prime }|）<1$的最小整数。

3.6使用如下方法规范化如下数据组：$$200,300,400,600,1000$$

（a）令$min=0,max=1$，最小最大规范化。

$$v_1=0,v_2=\frac{300-200}{1000-200}=0.125,v_3=\frac{400-200}{1000-200}=0.25,v_4=\frac{600-200}{1000-200}=0.5,v_1=1$$

（b）z分数规范化。

$$\bar{A}=500,{\sigma }_A=316.23,$$ $$v_1=\frac{200-500}{316.23}=-0.95,v_2=\frac{300-500}{316.23}=-0.63,v_3=\frac{400-500}{316.23}=-0.32$$ $$v_4=\frac{600-500}{316.23}=0.32,v_5=\frac{1000-500}{316.23}=1.58$$

（c）z分数规范化，使用均值绝对偏差而不是标准差

$$\bar{A}=500,s_A=240,$$$$v_1=\frac{200-500}{240}=-1.25,v_2=\frac{300-500}{240}=-0.83,v_3=\frac{400-500}{240}=-0.42$$ $$v_4=\frac{600-500}{240}=0.42,v_5=\frac{1000-500}{240}=2.08$$

（d）小数定标规范化

$$v_1=0.02,v_2=0.03,v_3=0.04,v_4=0.06,v_5=0.1$$

3.7使用习题3.3中给出的age数据，回答以下问题：

（a）使用最小-最大规范化将age值35变换到[0.0,1.0]区间。

$$v=\frac{35-13}{70-13}=0.404$$

（b）使用z分数规范化变换age值35，其中age的标准差为12.94岁。

$$\bar{A}=29.96$$$$v=\frac{35-29.96}{12.94}=0.39$$

（c）使用小数定标规范化变换age值35.

$$v=\frac{35}{100}=0.35$$

（d）指出对于给定的数据，你愿意使用哪种方法。陈述你的理由。

最小-最大规范化方法，易于理解，计算简便。

3.8使用习题2.4中给出的age和%fat数据，回答如下问题：

age	23	23	27	27	39	41	47	49	50
%fat	9.5	26.5	7.8	17.8	31.4	25.9	27.4	27.2	31.2

age	52	54	54	56	57	58	58	60	61
%fat	34.6	42.5	28.8	33.4	30.2	34.1	32.9	41.2	35.7

（a）基于z分数规范化，规范化这两个属性。

$${\bar{A}}_{age}=46.44,{\sigma }_{A_{age}}=13.22,{\bar{A}}_{fat}=28.78,{\sigma }_{A_{fat}}=9.25,v_i^{\prime }=\frac{v_i-\bar{A}}{{\sigma }_A}$$

age	-1.77	-1.77	-1.47	-1.47	-0.56	-0.41	0.04	0.19	0.27
%fat	-2.08	-0.25	-2.27	-1.19	0.28	-0.31	-0.15	-0.17	0.26

age	0.42	0.57	0.57	0.72	0.80	0.87	0.87	1.03	1.10
%fat	0.63	1.48	0.00	0.50	0.15	0.57	0.44	1.34	0.75

（b）计算相关系数（Pearson积矩系数）。这两个变量是正相关还是负相关？计算它们的协方差。

$$r=\frac{\sum _{i=1}^{18}(ag{e}_i\ast fa{t}_i)-18\ast {\bar{A}}_{age}\ast {\bar{A}}_{fat}}{18\ast {\sigma }_{A_{age}}\ast {\sigma }_{A_{fat}}}\approx 0.77$$这两个变量是正相关的。$$Cov(age,fat)=\frac{\sum _{i=1}^{18}(ag{e}_i-{\bar{A}}_{age})(fa{t}_i-{\bar{A}}_{fat})}{18}\approx 94.46$$

3.9假设12个销售价格记录已经排序，如下所示：$$5，10，11，13，15，35，50，55，72，92，204，215$$使用如下各方法将它们划分成三个箱。

（a）等频（等深）划分。

箱1：5，10，11，13
箱2：15，35，50，55
箱3：72，92，204，215

（b）等宽划分。

箱1：5，10，11，13，15，35，50，55
箱2：72，92
箱3：204，215

（c）聚类。

箱1：5，10
箱2：11，13，15，35
箱3：55，72，92，204，215

3.10使用流程图概述以下属性子集选择过程

（a）逐步向前选择

（b）逐步向后删除

（c）结合逐步向前选择和逐步向后删除

3.11使用习题3.3中给出的age数据，

（a）画一个宽度为10的等宽的直方图

（b）简要描述如下每种抽样技术的例子：SRSWOR、SRSWR、簇抽样、分层抽样。使用大小为5的样本以及层“young”、“middle-aged”和“senior”。

无放回简单随机抽样（SRSWOR）。从N个个体中随机抽取n个个体，每次抽取一个个体，且抽取后不再放回。例如：13，16，21，25，30；15，19，22，35，52.
有放回简单随机抽样（SRSWR），与无放回类似，但是每次抽取个体之后，要放回。例如：13，15，21，25，30；13，19，22，30，35.
簇抽样，先将总体分为多个不相交的簇，然后再抽取一个或多个簇作为样本，要求簇内的差异较大，簇之间的差异较小，从而使得簇抽取的样本具有代表性。例如：13，20，30，40，70.
分层抽样，将总体分为多个不相交的部分，叫做层，然后按照一定的比例在每个层中进行抽样，要求层内差异较大，层之间的差异较小。例如：16，25，35，40，70.

3.12Chimerge[Ker92]是监督的、自底向上的（即基于合并的）数据离散化方法。它依赖于${\chi }^2$分析：具有最小${\chi }^2$值的相邻区间合并在一起，直到满足确定的停止标准。

（a）简略描述ChiMerge如何工作。

ChiMerge是一种基于${\chi }^2$的离散化方法。采用自底向上的策略，递归地找出最邻近的区间，然后合并它们，形成较大的区间。与决策树分析一样，ChiMerge是监督的，因为它使用类信息。其基本思想是，对于精确的离散化，相对类频率在一个区间内应当完全一致。因此，如果两个邻近的区间具有非常类似的类分布，则这两个区间可以合并；否则，他们应当保持分开。
ChiMerge过程如下。初始时，把数值属性A的每个不同值看做一个区间。对每对相邻区间进行${\chi }^2$检验。具有最小${\chi }^2$的相邻区间合并在一起，因为低${\chi }^2$值表明它们具有相似的类分布。该合并过程递归地进行，直到满足预先定义的终止条件。

（b）取鸢尾花数据集作为待离散化的数据集合，鸢尾花数据集可以从UCI机器学习数据库（www.ics.uci.edu/~mlearn/MLRepository.html）得到。使用ChiMerge方法，对四个数值属性分别进行离散化。（令停止条件为：$max-interval=6$）。你需要写一个小程序，以避免麻烦的数值计算。提交你的简要分析和检验结果：分裂点、最终的区间以及源程序文档。

def read(file):
    '''read raw date from a file '''
    Instances=[]
    fp=open(file,'r')
    for line in fp:
        line=line.strip('\n') #discard '\n'
        if line!='':
            Instances.append(line.split(','))
    fp.close()
    return(Instances)
 
def split(Instances,i):
    ''' Split the 4 attibutes, collect the data of the ith attributs, i=0,1,2,3
        Return a list like [['0.2', 'Iris-setosa'], ['0.2', 'Iris-setosa'],...]'''
    log=[]
    for r in Instances:
        log.append([r[i],r[4]])
    return(log)
 
def count(log):
    '''Count the number of the same record
       Return a list like [['4.3', 'Iris-setosa', 1], ['4.4', 'Iris-setosa', 3],...]'''
    log_cnt=[]
    log.sort(key=lambda log:log[0])
    i=0
    while(i<len(log)):
        cnt=log.count(log[i])#count the number of the same record
        record=log[i][:]
        record.append(cnt) # the return value of append is None
        log_cnt.append(record)
        i+=cnt#count the next diferent item 
    return(log_cnt)
 
def build(log_cnt):
    '''Build a structure (a list of truples) that ChiMerge algorithm works properly on it '''
    log_dic={}
    for record in log_cnt:
        if record[0] not in log_dic.keys():
            log_dic[record[0]]=[0,0,0]
        if record[1]=='Iris-setosa':
            log_dic[record[0]][0]=record[2]
        elif record[1]=='Iris-versicolor':
            log_dic[record[0]][1]=record[2]
        elif record[1]=='Iris-virginica':
            log_dic[record[0]][2]=record[2]
        else:
            raise TypeError("Data Exception")
    log_truple=sorted(log_dic.items())
    return(log_truple)
 
def collect(Instances,i):
    ''' collect data for discretization '''
    log=split(Instances,i)
    log_cnt=count(log)
    log_tuple=build(log_cnt)
    return(log_tuple)
 
def combine(a,b):
    '''  a=('4.4', [3, 1, 0]), b=('4.5', [1, 0, 2])
         combine(a,b)=('4.4', [4, 1, 2])  '''
    c=a[:] # c[0]=a[0]
    for i in range(len(a[1])):
        c[1][i]+=b[1][i]
    return(c)
 
def chi2(A):
    ''' Compute the Chi-Square value '''   
    m=len(A);
    k=len(A[0])
    R=[]
    for i in range(m):
        sum=0
        for j in range(k):
            sum+=A[i][j]
        R.append(sum)
    C=[]
    for j in range(k):
        sum=0
        for i in range(m):
            sum+=A[i][j]
        C.append(sum)
    N=0
    for ele in C:
        N+=ele
    res=0
    for i in range(m):
        for j in range(k):
            Eij=R[i]*C[j]/N
            if Eij!=0:
                res=res+(A[i][j]-Eij)**2/Eij
    return res
 
def ChiMerge(log_tuple,max_interval):
    ''' ChiMerge algorithm  '''
    ''' Return split points '''    
    num_interval=len(log_tuple)
    while(num_interval>max_interval):               
        num_pair=num_interval-1
        chi_values=[]
        for i in range(num_pair):
            arr=[log_tuple[i][1],log_tuple[i+1][1]]
            chi_values.append(chi2(arr))
        min_chi=min(chi_values) # get the minimum chi value 
        for i in range(num_pair-1,-1,-1): # treat from the last one
            if chi_values[i]==min_chi:
                log_tuple[i]=combine(log_tuple[i],log_tuple[i+1]) # combine the two adjacent intervals
                log_tuple[i+1]='Merged'
        while('Merged' in log_tuple): # remove the merged record
            log_tuple.remove('Merged')
        num_interval=len(log_tuple)
    split_points=[record[0] for record in log_tuple]
    return(split_points)
 
def discrete(path):
    ''' ChiMerege discretization of the Iris plants database '''
    Instances=read(path)
    max_interval=6
    num_log=4
    for i in range(num_log):
        log_tuple=collect(Instances,i) # collect data for discretization
        split_points=ChiMerge(log_tuple,max_interval) # discretize data using ChiMerge algorithm 
        print(split_points)
if __name__=='__main__':
    discrete('iris.csv')

分裂点如下

['4.3', '4.9', '5.0', '5.5', '5.8', '7.1']
['2.0', '2.3', '2.5', '2.9', '3.0', '3.4']
['1.0', '3.0', '4.5', '4.8', '5.0', '5.2']
['0.1', '1.0', '1.4', '1.7', '1.8', '1.9']

3.13对如下问题，使用伪代码或你喜欢用的程序设计语言，给出一个算法：

（a）对于标称数据，基于给定模式中属性的不同值的个数，自动产生概念分层。

（b）对于数值数据，基于等宽划分规则，自动产生概念分层。

（c）对于数值数据，基于等频划分规则，自动产生概念分层。

3.14数据库系统中鲁棒的数据加载提出了一个挑战，因为输入数据常常是脏的。在许多情况下，数据记录可能缺少多个值，某些记录可能被污染（即某些数据值不在期望的值域内或具有不同的类型）。设计一种自动数据清理和加载算法，使得有错误的数据被标记，被污染的数据在数据加载时不会错误地插入到数据库中。

致谢

感谢广大网友！
主要参考内容：
[1]https://blog.csdn.net/zhaoyl03/article/details/8689440