CN101241502A - 基于语义距离模型的xml文档关键字搜索聚类方法 - Google Patents

Abstract

本发明属于Web数据管理技术领域，具体为一种基于语义距离模型的可扩充标记语言(XML)的关键字搜索方法，称为XKLuster。本发明提出一种新的模型，称为“XML关键字语义距离模型”。它通过更全面地考虑XML的层次结构特征来度量XML关键字搜索的语义；基于本发明提出的“XML关键字语义距离模型”，从不同的角度，设计三种聚类算法：基于图的关键字聚类算法(GKSC)、核心集驱动的关键字聚类算法(CKSC)和松弛的核心集驱动聚类算法(LCC)；提出一种排序模型对所有的搜索结果进行排序，以便将搜索结果返回给用户。与已有方法相比，本发明提出的方法可得到更加合理的返回结果。本发明可用于互联网上的XML文档搜索、XML数据库的搜索等领域。

Description

基于语义距离模型的XML文档关键字搜索聚类方法

技术领域

本发明属于Web数据管理技术领域，具体涉及一种基于聚类思想，对可扩充标记语言(XML)数据库或文档进行关键字搜索的方法。

背景技术

由于界面友好、使用简单，关键字搜索在信息检索领域取得了巨大成功，例如谷歌搜索引擎、百度搜索引擎等。它们的搜索对象通常是一个HTML文档或普通文本文档的集合，搜索的目的是查出哪些关键字在哪些文档中出现，并且返回全部或部分包含关键字的文档。由于XML格式数据的大量出现和广泛应用，在XML文档上进行关键字搜索的需求变得越来越迫切。近年来，XML关键字搜索受到工业界和学术界的广泛关注^{[1][2][3][4][5][6][7]}。XML的关键字搜索不同于结构化的XML查询(如XPath、XQuery等)，不仅易于使用，用户不需要学习和掌握复杂的查询语言，用户也不需要了解XML的模式，适用于Internet上大量存在的自由XML文档。但是，关键字搜索带来的一个关键问题是用户难以或无法准确表达搜索语义。因此，在XML关键字搜索中，如何确定关键字搜索的语义(即用户的搜索意图)以及返回什么样的结果给用户则成为关键的技术难点。

在已有的关于XML关键字搜索的工作中，通常都是基于最低公共祖先(LCA)模型，中一个典型的方法是最小最低公共祖先方法SLCA(Meaningful Lowest Common Ancestor)^[2]。Li等人^[3]将关键字搜索的语义定义为有意义的最低公共祖先，其本质含义与SLCA相同。SLCA方法返回的是一组最小应答子树(smallest answer subtree)，一棵最小应答子树被定义为：包含有所有关键字的子树，并且任意一棵其子树都不包含所有关键字，这种子树的根被称作一个SLCA。SLCA方法实际上是将对一组关键字的搜索转换为对这一组关键字的最小最低公共祖先的查找。该方法虽然能够获得一些关键结果，但同时又会丢失很多有意义的信息。例如，图1所示是一个XML文档树，其中每个结点以自己的标签作为标识，下面的数字串是该结点的Dewey编码。假如用户搜索的关键字是{XML，Michael，David}，标签中包含关键字的结点用下划线标出。

在图1中，SLCA方法的返回结果只是一棵以结点Article(0.2.2.0)为根的子树。然而，用户的搜索语义极有可能是“Michael和David曾经合作写过哪些关于XML的文章”，很明显，SLCA方法找到了文章“XML3”，但将文章“XML2”漏掉了；用户还可能有其它合理的查询意图，比如“Michael和David一起合作写过哪些文章”，“Michael和David其中任一个人写过哪些关于XML的文章”，对于这两个询问，文章“HTML1”和文章“XML1”也是满足的，都应该被返回。这些搜索意图都是很合理的，也是现实生活中非常常见的，而SLCA方法将几个满足这些搜索意图的结果都丢失了。

实际上，SLCA方法所做的即是根据某种规则从各种包含不同关键字的结点的组合中挑选出部分“最优”的包含全部关键字的组合，而SLCA方法认为的“最优”就是LCA相对最低，而LCA相对较高的结果则都被丢弃了，这是SLCA方法会丢失有意义的结果的根本原因。除了丢失一些有意义的结果外，SLCA方法还存在一些其它问题：(1)在其计算过程中，并不是所有的结点组合都是可比较的，所有LCA之间不存在祖先后代的两个组合，例如图1中的组合{0.2.2.0.1.0，0.2.2.0.1.1}与组合{0.0.1.0，0.0.1.1}，都不可比较，所以选出的”最优”只能是相对最优；(2)由于SLCA方法选出来的一组结果的LCA之间都不存在祖先后代关系，所以它们是不可比较的，因此也无法将它们排序，这显然不适合结果集比较大的情况；(3)SLCA方法要求每个结果都要包含所有关键字，这实际是要求在作为查询语句的所有关键字之间存在“与”逻辑关系，而我们现实生活中所使用的关键字搜索引擎(例如谷歌)都包含了“或”关系，也就是说关键字可以全部或部分的存在于结果中，这使得搜索的结果能更多地满足用户的可能意图，显然更加合理，也应该被应用到XML关键字搜索中来。

针对上述问题，本发明提出一种新的XML关键字搜索的处理方法。其中，提出一种新的XML关键字搜索的语义距离模型，综合考虑关键字结点之间的距离和它们的LCA的高度；首次使用聚类算法进行XML关键字搜索；并提出一种排序模型对所有的搜索结果排序。

发明内容

本发明的目的在于提出一种新的XML文档关键字搜索方法，以便能够搜索到更多的对用户有意义的XML片断。

本发明提出的XML文档关键字搜索方法，是基于XML文档距离模型的XML聚类关键字搜索，包括用关键字的语义距离模型来建模用户的搜索意图、用聚类算法进行关键字搜索、支持关键字之间的“或”运算、并对结果进行排序，记为XKLuster。方法的具体步骤如下：

(1)定义用户提交的关键字，并将XML文档的关键字搜索语义定义为关键字之间的语义距离模型，并以此来表示用户的搜索意图；

(2)将关键字搜索的返回结果定义为关键字簇的最小组成树；

(3)XML文档树进行预处理；

(4)根据本发明提出的语义距离模型，选择使用如下三种聚类算法之一种进行XML关键字搜索：基于图的聚类算法(GKSC)、核心集驱动的聚类算法(CKSC)和松弛的核心集驱动聚类算法(LCC)。

(5)根据本发明提出的排序模型，对搜索结果进行排序。

1.定义关键字之间的语义距离模型

本发明将用户提交的关键字定义为一个包含t个关键字的集合L＝{k_i|i＝1，…，t}，XML文档定义为一棵XML文档树，具体如下：

定义1.XML文档树。将一颗XML文档树(XML Document Tree)表示为一个8元组d＝(V，E，X，label(id)，pl(id₁，id₂)，depth(id)，dwcode(id)，lca(V′))，其中：

(1)V是树上所有结点的集合，并且每个结点都有唯一的标识符和Dewey编码；

(2)EV×V，是树上边的集合；

(3)label(id)为标签函数，用来获得标识为id的结点的标签，其中id∈V；

(4)XV是树上所有关键字结点的集合，所谓关键字结点即标签中包含关键字的结点；

(5)pl(id₁，id₂)函数，用来取得id₁和id₂两个结点之间的路径长度，其中id₁和id₂必须具有祖先后代关系，而此函数返回的结果为它们之间的路径上所包含的边的个数；

(6)depth(id)函数，用来获得标识为id的结点的深度(树的根的深度为1)，其中id∈V；

(7)dwcode(id)函数，用来获得标识为id的结点的Dewey编码，其中id∈V；

(8)lca(V′)函数，其中V′V是V的任意子集，函数返回V′中所有结点的最低公共祖先。

定义2.两个关键字结点之间的最短路径。两个关键字结点x_i和x_j的最短路径为结点x_i到lca({x_i，x_j})的路径加上结点x_j到lca({x_i，x_j})的路径。同时，用函数spl(x_i，x_j)来表示结点x_i和x_j的最短路径的长度，显然spl(x_i，x_j)＝pl(lca({x_i，x_j})，x_i)+pl(lca({x_i，x_j})，x_j)。

在一篇普通的文本文档中，两个单词之间到底有多“近”，可以直接通过它们中间相隔的单词数量来表示。但是在一篇XML文档中，情况更为复杂。实际上，在现有的XML关键字搜索方法中，都显示或隐式地定义了任意两个关键字结点在结构上的距离。比如Hristidis等人在[1]中将两个结点之间的距离直接定义成它们的最短路径的长度，但没有考虑到树型结构层次化的特性。而在所有基于LCA的方法的主要缺陷有三：一是虽然考虑到了层次的高低，但是没有考虑结点之间的路径长短；二是当两个LCA之间具有祖先后代关系时，只取SLCA会导致部分有意义的结果的丢失；三是当两个LCA之间不具有祖先后代关系时，两个距离是不可比较的，因而无法对大量返回结果进行排序。

本发明综合考虑两方面因素来定义两个关键字之间的语义距离，即两个关键字结点之间的路径长度和它们的LCA的层次。若两个关键字结点之间的最短路径越短，则它们的语义距离越近；若两个结点的LCA的层次越低，则它们的语义距离越近；两个关键字之间的语义距离越短，则意味着它们的关系更紧密，更可能构成用户要搜索的结果。这样的语义距离模型避免了当两个LCA之间不具有祖先后代关系时会丢失可能的结果；同时在存在大量返回结果时，又能够对返回结果进行排序。

定义3.两个关键字结点之间的语义距离。XML文档树上任意两个关键字结点之间的语义距离dis(x_i，x_j)被定义如下：

$\mathrm{dis}(x_i,x_j)=\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}---\left(1\right)$

后面内容将语义距离简称为距离。在公式(1)中，分子和分母部分分别是两关键字结点间最短路径的长度和它们LCA的高度。设树的高度(最大深度)是h，那么spl(x_i，x_j)的取值范围是[0，2h]，而depth(lca({x_i，x_j}))的取值范围是[1，h]，所以dis(x_i，x_j)的值域是[0，2h]。对图1中的所有关键字之间的语义距离进行计算，可以得到一个语义距离矩阵，如表1所示。

由表1中可以看出，最近的几个距离(0.40和0.67)表示的关系都是同一篇文章的两个作者，而最远的距离(8.00)则是相互之间没有引用关系的两篇文章的标题或作者，距离的远近与实际意义相符。

2.定义关键字搜索的返回结果

定义4.关键字结点的簇。根据关键字语义距离模型，可以使用特定的方法将关键字结点集分成一组簇。簇的集合表示为C＝{C_i|i＝1，…，m}，其中，一个簇C_i是一组关键字结点的集合，C_iX，且 $\underset{i=1}{\overset{m}{\∪}}{C}_i=X.$

设定一个距离阈值ω来约束簇的大小，簇中任意两个关键字结点之间的距离小于等于ω。

定义5.最优簇。给定一个距离阈值ω，任一个关键字集合C_iX被称为最优簇，当且仅当：(1)x_i，x_j∈C_i满足dis(x_i，x_j)≤ω；(2)x_a，x_a∈X且x_aC_i，x_b∈C_i满足dis(x_a，x_b)＞ω。

假设取距离阈值为2.0，则可知表1中的距离矩阵中只有部分距离被保留(如表1中阴影部分所示)，此时的四个最优簇分别是{x₁，x₂}，{x₃，x₄}，{x₅，x₆，x₇，x₈}和{x₉，x₁₀，x₁₁}，将四篇文章都找出了。由于一个簇只是若干关键字结点的集合，若要向用户返回有价值的信息，一种简单的方法是对于每个簇C_i，返回整棵以lca(C_i)为根的子树。但存在两个缺点：其一是多个lca(C_i)为根的子树之间可能存在的包含情况，尤其当某个lca(C_i)的层次比较高的时候，会产生大量冗余信息；其二是返回结果过大。因此，本发明将返回结果定义为簇的“最小组成树”，定义如下：

定义6.簇的最小组成树。C中每个簇C_i的最小组成树定义为：以lca(C_i)为根，以descendants(C_i)中的所有结点为叶子的树。其中descendants(C_i)函数返回C_i中所有在C_i内不含有任何后代的关键字结点的集合。即就是C_i的最小组成树是从lca(C_i)到descendants(C_i)中所有结点的。

在将每个簇的最小组成树返回给用户后，再为用户提供两个额外功能来扩大返回结果：一是对任意结点的“展开”，将原XML文档树中该结点的所有后代结点加入到结果中，例如在图1中，对于簇{0.1.0.0，0.1.1.0}的最小组成树，用户可以展开Authors(0.1.1)结点来获得该篇文章的另一个作者John(0.1.1.1)；二是根结点的提高，即将当前最小组成树根结点的父结点加入到结果中，例如对于簇{0.0.1.0，0.0.1.1}的最小组成树，用户可以将根结点Authors(0.0.1)提高，从而得知其父结点Article(0.0)。通过这两个功能的组合，用户可以根据自己的需求来随意扩展每个结果的大小，直至找到满意的内容为止。

3.XML关键字搜索的聚类算法的预处理

在数据挖掘中，聚类是一个常用的处理方法。它将一个对象集合分成一些组，使得同一个组内对象之间的相似度达到最大，而不同组间对象的相似度达到最小。在XML关键字搜索的背景下，本发明的目标是将一个关键字结点集合按照结点间语义距离的远近进行分组。本发明针对XML关键字搜索，设计了相应的的聚类算法。对于一个距离阈值ω，XML关键字聚类搜索的目标就是找到所有的最优簇。在说明XML关键字聚类算法之前，先对XML文档树进行预处理，步骤如下：

(1)使用Dewey编码为整棵XML文档树进行编码；

(2)为所有的关键字建立倒排索引表；

(3)对于深度(最大高度)为h的XML文档树，建立一个包含有h个有序关键字结点列表的层次型数据结构H。其中每一个层次是将XML文档树上一组处于同一高度的多个结点按照文档访问(先序遍历)顺序组成一个序列I，x_i是其中的任一个结点；

(4)先序遍历XML文档树，每遇到一个标签含有关键字的结点，将它加入相应层次的列表的尾部。

当文档遍历结束时，可以得到一个如图2所示的层次型数据结构H。在该结构的任一层次的列表上，结点是按照文档访问(先序遍历)顺序加入的，因而有如下定理：

定理1.在序列I中，当从结点x_i向左(向右)进行遍历时，x_i与每次遇到的结点之间的距离非递减增加。

证明.从结点x_i开始，无论是向左还是向右遍历，每次遇到的结点与x_i的关系总会依次是“兄弟”、“堂兄弟”…，越来越疏远，从而彼此间的最短路径越来越长，LCA也越来越高，根据公式1可知距离越来越远。

对于文档树上的任意一个低(高)于I所在位置的层次，同样按顺序取任意多个结点组成序列I′，并且设I′中一个结点x_j是x_i的后代(祖先)结点(如果有多个后代结点，则任选一个；如果不存在后代结点，则在相应位置插入一个)，定理2如下：

定理2.在序列I′中，当从x_j开始向左(向右)遍历，则x_i与每次遇到的结点之间的距离非递减增加。

证明.x_i与序列I′中任意一个结点的最短路径等于x_j和该点的最短路径减去(加上)x_i和x_j的最短路径，而在I′确定的情况下，x_i和x_j的最短路径是不变的，所以x_i与该结点的最短路径长度越来越短，而显然它们的LCA的深度是减小的，所以可得证距离增加。

4.基于图的的关键字搜索聚类算法GKSC(Graph-based Clusteringalgorithm for XML Keyword Search)

GKSC算法首先遍历H，根据彼此距离是否小于等于距离阈值建立结点和结点之间的连接，从而得到一个以各个关键字结点为顶点的加权无向图G，再使用一个图的分解算法来获得一组最大完全子图，各个完全子图的顶点集合就是一个最优簇。GKSC算法的步骤如下：

(1)从上到下按层次访问H中的结点，在每一层的列表中，从左到右遍历，对于当前访问结点，计算它和同层右边以及下面的某些邻居的距离。假设当前正在访问结点x_i，则它和同一层次处于它左边的邻居结点的距离，以及和它上面的层次的邻居结点的距离都已经被计算过了，因此只需要考虑右边以及更低层次的结点。假设被考虑的结点是x_j，并且处在x_i的同一层次，根据定理1，随着x_j的位置向右移动，dis(x_i，x_j)一直变大。所以，当dis(x_i，x_j)大于ω时，x_j右边的结点都不需要再被考虑。

(2)对于更低层次的结点，首先确定有多少层次的结点需要被考虑。给定一个ω，距离公式必须满足 $\mathrm{dis}(x_i,x_j)=\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}\≤\mathrm{\ω},$ 又由于depth(x_i)≥depth(lca({x_i，x_j}))，所以 $\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(x_i\right)}\≤\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}\≤\mathrm{\ω}$ 成立，也就是说spl(x_i，x_j)≤depth(x_i)×ω，所以floor(depth(x_i)·ω)是x_i下面必须考虑的层次的数目，其中floor函数表示向下取整。可以发现，即使x_i在第(floor(depth(x_i)·ω)+1)个更低的层次有一个后代结点，它和该后代之间的距离也肯定超过了距离阈值。

(3)计算出所需要考虑的层次数目后，对于x_i下方floor(depth(x_i)·ω)层中的每一层，首先找到x_i的后代在该层中的位置(x_i的后代结点不需要一定在H中存在)，再从该位置向左(向右)遍历直至距离超出阈值，并且根据定理2，在这一层中，其它结点都不需要参与考虑。当x_i是所属层中的第一个结点时，使用二分法去寻找它在floor(depth(x_i)·ω)个低层次列表中后代结点的位置，并且用指针记录下这些位置(如图2所示)。而当x_i不是第一个结点时，只从那些记录的位置开始向右寻找后代结点的位置，之后再修改指针到当前位置。这样做的原因是：假设x_i和x_j在同一层中两个相邻的位置，x_i在x_j的左边，则在更低的一个层次中，x_j的后代结点的位置肯定在x_i的后代结点位置的右边，这样处理的话指针只朝一个方向移动，它的变化是累加式的，比每次都用二分法寻找后代结点的位置要高效得多。

(4)每次计算两个结点的距离时，如果小于或等于距离阈值，则(通过加上互相指向的指针)将该两个结点用边连接起来，并且记录下距离作为该边的权。

(5)上一步结束后，可以得到一个加权的无向图。然后再将图分解得到所有的最大完全字图，从而得到结果簇。

算法GKSC能够找到所有的最优簇，完全达到了聚类的目标，其不足在于效率较难控制，尤其是在距离阈值比较大的时候效率可能会比较低。因此，本发明提出另外两个聚类算法：CKSC和LCC。

5.核心集驱动的聚类算法CKSC(Core-driven Clustering algorithm forXML Keyword Search)

CKSC的思路则是利用分而治之的思想，首先找到一些被称为核心集(core)的结点集。若是核心集，则在它之内的结点肯定能被聚到一起；再找到一些肯定包含最优簇的核心集的集合；最后从这些核心集集合中找到最优簇。

定义7.核心集。对于距离阈值ω来说，任一个关键字集合C_oX，如果它所包含的关键字结点中任意两者之间的距离都小于或等于ω，则C_o被称为一个核心集(core)。

根据定义7，任意一个最优簇都是一个核心集。但是，一个核心集不一定是一个最优簇。

引理1.设在层次型数据结构H的任一层中取x_l和x_r两个任意结点，其中，x_r在r_l右边。对于一个距离阈值ω，若dis(x_l，x_r)≤ω，则从x_l到x_r这(r-l+1)个结点的集合是一个核心集。

证明.设从x_l到x_r这(r-l+1)个结点中任取两个结点x_a，x_b，并且x_b在x_a的右边，则根据定理1可知dis(x_a，x_b)≤dis(x_a，x_r)≤dis(x_l，x_r)≤ω，即任意两个结点之间的距离小于等于ω，得证。

定义8.原始核心集。H中的一个结点集合C_o’被称为一个原始核心集(core origin)，当且仅当：(1)C_o’是一个核心集；(2)C_o’中的结点都处于H的同一层次；(3)在该层次中不存在一个核心集C_o使得C_o’C_o。

GKSC算法步骤的说明如下：

(1)首先遍历H，将H中的结点分成一些核心集。对于H的每一层，具体的做法是：创建一个空集，将该层第一个结点加入，从第二个结点开始往后遍历，计算第一个结点与遍历当前结点之间的距离；如果小于等于ω则将之加入集合。当遇到距离超出ω的第一个结点时，再创建一个空集，以该结点为集合中第一个结点继续遍历，直至该层中所有结点都已遍历完。一个原始核心集所包含的是H上同一层次中相邻的一组结点。如图3(a)所示，假设dis(x_l，x_r)≤ω，并且dis(x_l-1，x_l)＞ω，dis(x_r，x_r+1)＞ω，根据引理1可知，{x_l，…，x_r}是个核心集，并且对于其中的任一个结点x_a，dis(x_l-1，x_a)＞dis(x_l-1，x_l)＞ω，dis(x_a，x_r+1)＞dis(x_r，x_r+1)＞ω，即x_a与同一层内其它结点的距离都大于ω。所以，{x_l，…，x_r}是一个原始核心集。实际上它是该层所有结点集合的一个最优簇。

(2)再寻找原始核心集周围的核心集，求出包含这些原始核心集的最优簇。如前所述，对于一个原始核心集来说，同一层次中所有其它结点都不需要再考虑，只需考虑其它所有层次的相邻结点。如图3(b)所示，假设当前考虑的原始核心集是I中的{x_l，…，x_r}，观察该层下面某个序列I’中的结点，按照GKSC算法中寻找连接的做法可以得到一组连续的与结点x_l距离小于等于ω的结点。将这些结点设为x_l’，…，x_l″，将与结点x_r距离小于等于ω的一组连续结点设为x_r’，…，x_r″。假设{x_l’，…，x_l″}与{x_r’，…，x_r″}没有交集，则I’中不存在可以被加入核心集{x_l，…，x_r}以形成最优簇的结点。但如果两者的交集如图中所示是{x_r’，…，x_l″}，且在一个核心集内，则{x_l，…，x_r}∪{x_r’，…，x_l″}是一个核心集。另外当，{x_r’，…，x_l″}不是一个核心集的时候(x_r’到x_l″跨越多个核心集)，将它划分成几个核心集再予以考虑，对于每个核心集可以得到相同的结论。当找出{x_l，…，x_r}在所有层次上需要考虑的核心集后，在每一层取一个核心集组成一个核心集的集合，显然可以在该集合内找到包含{x_l，…，x_r}的最优簇。

引理2.结点集合{x_l，…，x_r}∪{x_r’，…，x_l″}是一个核心集，且除{x_r’，…，x_l″}之外的I’中的点都不能被加入{x_l，…，x_r}而成为一个核心集。

证明.{x_l，…，x_r}与{x_r’，…，x_l″}本身都是核心集，所以只需证明两个集合中各任取一个结点，距离小于等于距离阈值。设在{x_l，…，x_r}中任取一个结点x_a，{x_r’，…，x_l″}中任取一个结点x_a’，假设dis(x_a，x_a’)＞ω，则根据定理2，若dis(x_l，x_a’)≤ω，则x_a’在该层中的祖先应该在x_a的左边；若dis(x_r，x_a’)≤ω，则x_a’在该层中的祖先应该在x_a的右边；而很显然dis(x_l，x_a’)与dis(x_r，x_a’)都小于等于ω，则x_a’的祖先的位置矛盾，所以dis(x_a，x_a’)≤ω。至于I’中的其它结点，则很明显至少与x_l和x_r中一者的距离超过ω，得证。

显然，同理可以证明对于I上方的任一个层次，引理2同样成立。这实际上是相当于先从每一层中挑选部分结点，再从这些结点构成的子图中寻找一个最大完全子图。

6.松弛的核心集驱动聚类算法LCC(Loosen Core-driven Clusteringalgorithm for XML Keyword Search)

上面两个算法虽然有时候效率会很高，但仍然存在不可准确预期的低效情况，尤其是算法GKSC强烈依赖于距离阈值对两结点间连接数的影响。由于在大多数情况下，用户对结果并没有太精确的要求，因而，可以放松对结果集的要求，允许一些距离稍远的结点在同一个结果中出现，以提高算法的效率。算法LCC正是基于这样一个思想，它放松对每个结果集必须是最优簇的要求，取而代之的是必定包含最优簇的一个结点集合。

算法LCC的步骤如下：

(1)算法LCC开始时处理仍然和CKSC一样。首先遍历层次型数据结构H，得到一组原始核心集；

(2)对于H中的每一层建立两个列表：头结点列表HNL和尾结点列表TNL。其中，HNL和TNL分别按顺序存放该行中所有原始核心集的第一个和最后一个结点；

(3)对于每个原始核心集C_o’，寻找其它所有层次中的一些原始核心集，这些原始核心集中存在结点到所有C_o’中结点的距离都小于等于ω；

(4)找到这些原始核心集后，不是试图在其中寻找最优簇，而是简单地将它们合并到C_o’中形成一个结果集。

7.搜索结果的排序

由于考虑尽量不丢失有意义的结果，本发明设计的聚类算法有时会产生大量结果，因此，需要对搜索结果进行排序。在关键字搜索的现有工作中，已经提出一些排序模型。例如，有些是基于图上的路径^[1][8][9]，有些则是借用信息检索中的方法^[5][6]。

本发明针对上面设计的聚类搜索算法，设计了特定的排序方法。它考虑俩方面的因素：

(1)首先，结果中出现的关键字种类越多，排序的优先级越高；这是显然的，如果用户想查的一些内容都没有在某个结果中出现，则该结果肯定不是最优的。

(2)对于关键字出现种类相同的结果，比较它们在结构上的差别，由此引入一个结果簇的“平均距离”的概念：

定义8(结果簇的平均距离)。对于结果簇集合C中任一个簇C_i，它的平均距离dis_mean为它所包含的所有结点之间两两距离的平均值，假设m是C_i所包含的结点的个数，则C_i的平均距离如公式(2)所示

${\mathrm{dis}}_{\mathrm{mean}}\left(C_i\right)=\left\{\begin{array}{c}\frac{\underset{x_i,x_j\∈C_i;x_i\≠x_j}{\mathrm{\Σ}}\mathrm{dis}(x_i,x_j)}{2C_m^2},m>1\\ \∞,m=1\end{array}\right.---\left(2\right)$

显然，一个簇的平均距离越小，则说明它含有的结点在结构上越紧凑，从而说明它能构成更好的返回结果。所以排序函数实际上就是取平均距离的倒数，平均距离越小，则排的越高。整个排序的过程如下：

(1)首先根据每个簇含有关键字的情况进行分组。所有含有相同关键字种类个数的簇被分入一组，对组进行排序，含有越多关键字种类的组排得越靠前；

(2)对于同一组内的簇，计算它们的平均距离。平均距离越小的簇在组内排得越靠前。对所有的簇排好序后，为每个簇生成一个最小组成树，并按照顺序将它们返回给用户。

(3)单结点簇(簇中只包含一个关键字结点)包含的信息量自然要少于任一个非单结点簇的最小组成树，因此它们的平均距离定义为无穷大，所以它们会被排到整个结果序列的最后。

在图1中，当距离阈值被设定为2.0时会产生四个最优簇：C₁＝{x₁，x₂}，C₂＝{x₃，x₄}，C₃＝{x₅，x₆，x₇，x₈}和C₄＝{x₉，x₁₀，x₁₁}。其中，C₃和C₄包含三个关键字，C₁和C₂包含三个关键字。它们的平均距离分别为：dis_mean(C₁)＝0.67，dis_mean(C₂)＝2.00，dis_mean(C₃)＝1.33，dis_mean(C₄)＝0.80。首先四个簇根据包含的关键字情况被分成两组{C₃，C₄}，{C₁，C₂}，同一组内的簇再根据平均距离排序，最终四个簇的排列顺序是：C₄，C₃，C₁，C₂。

本发明针对XML关键字搜索，定义了XML关键字搜索的语义距离模型，设计了三个关键字搜索的算法和搜索结果的排序模型。本方法的具体操作过程包括：

(1)定义用户提交的关键字，并将XML文档的关键字搜索语义定义为关键字之间的语义距离模型，并以此表示用户的搜索意图。该语义距离模型综合考虑了两方面的因素来定义两个关键字之间的语义距离，即两个关键字结点之间的路径长度和它们的LCA的层次。

(2)将关键字搜索的返回结果定义为关键字簇的最小组成树，其中，定义的相关概念包括：关键字结点的簇、最优簇、簇的最小组成树。

(3)对XML文档树进行预处理。

(4)在本发明提出的语义距离模型的基础上，可以选择使用如下三种聚类算法进行XML关键字搜索：GKSC、CKSC、LCC。三个算法在执行之前都要进行预处理，包括如下步骤：a)使用Dewey编码为整棵XML文档树进行编码。b)为所有的关键字建立倒排索引表。c)对于深度(最大高度)为h的XML文档树，建立一个包含有h个有序关键字结点列表的层次型数据结构H。d)先序遍历XML文档树，每遇到一个标签含有关键字的结点，将它加入相应层次的列表的尾部。用户可以根据不同的需要，在GKSC、CKSC、LCC三个算法中间做出选择。

从结果集来看，算法GKSC它可以找到所有的最优簇；算法CKSC是由核心集驱动的，它基于一个假设，即所有最优簇必定包含最少一个原始核心集，所以它可能会丢失部分最优簇；算法LCC则不考虑最优簇的约束。从时间效率上来看，算法CKSC实际上是在算法GKSC的基础上采用分而治之的思想，总体性能优于算法GKSC；算法LCC是在CKSC的基础上进行了优化，时间效率要高于CKSC。从空间复杂度来看，算法GKSC需要储存两结点之间的连接以及距离值，所以当距离阈值比较大时需要额外O(n²)的储存空间。算法CKSC和LCC中需要记录所有的原始核心集(也可以只记录每个核心集的首尾两个结点，因为原始核心集的结点都是连续的)，需要O(n)的储存空间。另外，算法CKSC在寻找相关核心集时还需要建立“结点-原始核心集”索引表；算法LCC也需要另外两个列表HNL和TNL，所以算法CKSC和LCC又需要额外的O(n)的储存空间。再加上层次型数据结构H所占用的空间，算法CKSC和LCC所使用的空间几乎等同，都不大于3n。算法GKSC所占用的空间为(n+O(n²))，其中后一项的具体值取决于所生成的图中边的个数。图4显示了三个算法时间复杂度的比较。

(5)根据本发明提出的排序模型，对搜索结果进行排序。其中，定义了结果簇的平均距离。排序的步骤如下：a)首先根据每个簇含有关键字的情况进行分组。b)对于同一组内的簇，计算它们的平均距离。C)对所有的簇进行排序，平均距离越小的簇在组内排得越靠前。之后，为每个簇生成一个最小组成树，并按照顺序将它们返回给用户。

附图说明

图1为XML文档示例的树型结构。

图2层次型数据结构H示意图。

图3为查找核心集示意图。

图4为三个聚类算法的时间效率比较。

图5为针对DBLP和Treebank的不同平均关键字结点个数的比较。

图6为针对关键字个数的不同，对算法时间效率的比较。其中，

(a)为关键字个数是2时(数据集为DBLP)算法时间效率的比较。

(b)为关键字个数是2时(数据集为Treebank)算法时间效率的比较。

(c)为关键字个数是3时(数据集为DBLP)算法时间效率的比较。

(d)为关键字个数是3时(数据集为Treebank)算法时间效率的比较。

(e)为关键字个数是4时(数据集为DBLP)算法时间效率的比较。

(f)为关键字个数是4时(数据集为Treebank)算法时间效率的比较。

(g)为关键字个数是5时(数据集为DBLP)算法时间效率的比较。

(h)为关键字个数是5时(数据集为Treebank)算法时间效率的比较。

图7为不同关键字个数的算法聚集效果的比较，其中，

(a)为关键字个数是2时(数据集为DBLP)算法的聚集结果数量的比较。

(b)为关键字个数是2时(数据集为Treebank)算法的聚集结果数量的比较。

(c)为关键字个数是3时(数据集为DBLP)算法的聚集结果数量的比较。

(d)为关键字个数是3时(数据集为Treebank)算法的聚集结果数量的比较。

(e)为关键字个数是4时(数据集为DBLP)算法的聚集结果数量的比较。

(f)为关键字个数是4时(数据集为Treebank)算法的聚集结果数量的比较。

(g)为关键字个数是5时(数据集为DBLP)算法的聚集结果数量的比较。

(h)为关键字个数是5时(数据集为Treebank)算法的聚集结果数量的比较。

图8为聚类算法与IL的时间效率比较。

图9为试验数据的片断样例，其中，

(a)为XMark数据(版本0.92)的DTD的片段。

(b)为XMark数据(版本0.92)的文档片段。

表1为图1的语义距离矩阵。

具体实施方式

本发明的核心是在基于语义距离模型的基础上设计了三种聚类算法，具体实现的伪码如下

(1)GKSC算法

A_LGORITHM 1(G_RAPH-BASED C_LUSTERING)

Input：a hierarchical structure H

Output：a set of optimal clusters C

 1. for(every list l in H)  //top-down

 2.   for(every node x_i in l)  //left-right

 3.     find a rightward neighbor x_j

 4.     while(dis(x_i，x_j)＜＝ω)

 5.      link(x_i，x_j)；  //link two nodes

 6.      find next rightward neighbor x_j；

 7.    for(every list l′in floor(depth(x_i)·ω)layers below l)

 8.      p←findDescPosition(x_i，l′)；

 9.      traverse leftward and rightward from p until distance

         overflows and link x_i with neighbors close enough；

10.use graph partition algorithm to get optimal cluster set C；

findDescPosition(x_i，l′)  //find the position of a descendant of x_i in l′

1.  getx_i′s descendant x_j in l′；

2.  if(x_i is the frst element of l)

3.     use binary search to find p as the position of x_j in l′；

4.  else

5.     search rightwards from l′.pointer to find p as the position of x_j；

6.  l′.pointer←p；

7.  return p；

算法的第1至第9行是一个遍历层次型数据结构并建立图的过程。第10行是使用一个图分解算法来获得所有的最大完全子图。一个最大完全子图可以保证所有两两结点之间都有连接，并且再加入图中任一个其它结点都不能构成一个完全子图。所以，它的顶点集合与最优簇的定义相符。图分解算法详细的具体做法是：从图中任取一点，考虑与它相连的所有点是否构成一个完全子图，如此递归地计算出所有包含有该点的最大完全子图。对于找出的每个子图上任意一点，如果它没有连向子图外的边，则将它从图中删除。之后再任取图中一点继续算法，直至图空为止。这时可以获得一组彼此不包含的完全子图，即最大完全子图。

算法GKSC的时间复杂度不只和关键字结点的个数有关，而且受距离阈值的影响很大。在一种最坏情况，即阈值ω大于2h时，则在遍历H的过程中，每个结点都要与(n-1)个结点比较，所以时间复杂度是O(n²)。遍历结束后得到的是一个全连接图，每个结点的度都是(n-1)。虽然最终的结果是一个包含所有关键字结点的大簇，但由于寻找最大完全子图本身是个NP难的问题^[13]，当所有两两结点间都存在连接时，分解的时间复杂度会非常高(O(2ⁿ))。

(2)CKSC算法

A_LGORITHM 2(C_ORE-DRIVEN C_LUSTERING)

Input：a hierarchical structure H

Output：a set of optimal clusters C

 1. for(every list l in H)

 2.   Co←；

 3.   x_f←first node of l；

 4.   for(every node x_i in l)

 5.     if(dis(x_f，x_i)＜＝ω)

 6.       add x_i into Co；

 7.     else

 8.       save Co；

 9.       Co←；

10.       x_f←x_i；

11.  save Co；

12.for(every core Co)

13.  CS←findRelatedCores(Co)；

14.  c←CS；

15.  for(each core Co′in CS)

16.    c←c∩findRelatedCores(Co′)；

17.  add c into C；

findRelatedCores(Co)

 1.  CS←；

 2.  for(each layer l except the one Co belongs to)

 3.    Co′←；

 4.    x_l←the most left node in Co；

 5.    x_r←the most right node in Co；

 6.    p_l←findAnceOrDescPosition(x_l，l)；

 7.    p_r←findAnceOrDescPosition(x_r，l)；

 8.    use binary search to find x_l″；

 9.    use binary search to find x_r′；

10.    if(x_r′is x_l″or left of x_l″)

11.       add nodes from x_r′to x_l″into Co′；

12.       add Co′into CS；

算法第1至第11行是寻找所有的原始核心集的过程，时间花费为O(n)。第12行到第17行是为每个核心集寻找最优簇。方法findRelatedCores中所使用的方法findAnceOrDescPosition是从GKSC算法的方法findDescPosition变化而来。它除了可以寻找祖先结点的位置外，还有一个区别就是抛弃某些结点采取的遍历方式而只采用二分法查找。其原因是，由于只需要找每个原始核心集的首尾结点，而它们的祖先/后代结点的位置跳动比较大。方法findRelatedCores的第8和第9行为寻找任一层中应该被考虑的核心集的过程。

在方法findRelatedCores中，查找祖先(后代)结点位置(第6和第7行)的时间为O(log n)，第8行第9行的时间都为O(log n)，第11行是O(n)。所以，三者总共的时间复杂度为O(n)。对于每个原始核心集，寻找相关的核心集需要调用方法findRelatedCores一次；而对于找出的其它层次的核心集，为了寻找最优簇，每个最多需要调用方法findRelatedCores(h-1)次，也就是总共(h-1)²次。所以，算法CKSC的第12至17行所需的时间总共是(h-1)³·(4log n+n)。由于h总是一个常数，所以复杂度仍然是O(n)。设原始核心集的数目是m，可知算法CC的总时间复杂度是O(n+m·n)，也就是O(m·n)。由此可见，这与原始核心集的数量相关。与算法GKSC的情况刚刚相反：当距离阈值ω被设置的很小时，m接近于n，时间复杂度趋向O(n·log n)；而当ω很大时，m是一个常数，则复杂度为O(n)。最坏的情况为m趋向于n，复杂度为O(n²)。

(3)LCC算法

A_LGORITHM 3(L_OOSEN C_ORE-DRIVEN C_LUSTERING)

Input：a hierarchical structure H

Output：a set of clusters C

1.  find all cores origin；

2.  for(every core Co)

3.    CS←findRelatedCores(Co)；

4.    c←CS；

5.    for(each core Co′in CS)

6.      c←c∪Co′；

7.    add c into C；

findRelatedCores(Co)

 1.  CS←；

 2.  for(each layer l except the one Co belongs to)

 3.    x_l←the most left node in Co；

 4.    x_r←the most right node in Co；

 5.    p_l←findADPositionInHNL(x_l，l)；

 6.    p_r←findADPositionInTNL(x_r，l)；

 7.    find the most left x_l″satisfy to dis(x_l，x_l″)＞ω

       in the nodes of HNL right of p_l；

 8.    find the most right x_r′satisfy to dis(x_r，x_r′)＞ω

       in the nodes of HNL left of p_r；

 9.    if(x_r′is x_l″or left of x_l″)

10.       add all cores origin between x_r′and x_l″into CS；

其中，寻找初始核心集的过程与CKSC一样(第1行)。方法findRelatedCores与CKSC算法中的同名算法有所改变：findRelatedCores的第5、6行分别是从1的HNL和TNL而不是从1中寻找祖先(或后代)的位置，第7行和第8行则说明了如果在p₁(p_r)位置右边(左边)的某核心集的第一个(最后一个)结点与x₁(x_r)的距离超出ω，则该核心集往右(往左)所有的核心集都没有必要再考虑。可以看出方法findRelatedCores的第5到第8行，每一步的时间复杂度都是O(log n)，而第10行只需记录下相关的原始核心集，所以是常数。假设初始核心集的数量是m，那么显然算法LCC的时间复杂度为O(n+m·log n)；当m趋向于n时达到最坏情况O(n·log n)；当m为常数时达到最好情况O(n)。另外，由于不需要从一组原始核心集中找到最优簇，所以LCC调用方法findRelatedCores的次数要明显少于CC，从而它的时间复杂度拥有一个比CKSC小的常数。

为了证明本发明的效果，实现了相应的原型系统，从四个方面进行了一系列实验：(1)比较在同一距离阈值下三个聚类算法的效率和结果；(2)观察三个算法的效率和结果随着距离阈值变化而产生的变化；(3)对比不同文档上三个算法的效率和结果；(4)比较本发明的XKLuster方法和SLCA方法^[2]的效率和结果。系统运行在CPU频率2.8GHZ、内存2G的微机上，软件运行环境是Windows XP，JDK1.6和Tomcat6.0，XML解析器是Xerces。

用作比较三个聚类算法的数据集是DBLP(文档大小127M，结点总数6332225个)和Treebank(文档大小82M，结点总数3829511)^[12]。选用这两个文档的原因有二：(1)大量的结点数可以提供更加准确的实验结果；(2)两个文档的结构有很强的可比性：DBLP的DTD比较简单，因此文档结构很规整，树的高度也不大(最大深度为6，平均深度为2.9)，是属于典型的“宽且平”的XML文档，而Treebank则没有DTD，结构很复杂，树高也相对较大(最大深度为36，平均深度为7.9)。

首先为每个数据集建立一个单词表，其中包含有在XML文档中出现的一些单词，每个单词的出现频率在5,000到15,000之间。然后，每次随机从单词表中选出几个单词作为关键字，对XML文档进行搜索，反复运行四十次，再取结果的平均值作为实验结果。

图5为在不同的关键字个数情况下文档中平均含有的关键字结点总数的情况；图6和图7分别是三个聚类算法在两个文档上使用的时间效率和结果数量的比较。

当距离阈值比较大时，(DBLP从6.0开始，Treebank从8.0开始)，在实验用的硬件上运行算法GKSC无论从时间还是空间上来看已经很大，所以此时只比较算法CKSC和LCC。另外，在文档比较大时，所以很多情况下会搜索出大量只包含有单个关键字结点的簇，这些簇中的结点在距离阈值内无法找到任何一个相邻结点，为了使图的表达更加清晰，在结果个数比较时忽略这些簇，而只考虑包含有两个以上关键字结点的簇。

在图6中容易发现：(1)给定关键字个数和距离阈值，三个算法的时间花费从大到小依次是GKSC，CC，LCC。但当距离阈值非常小时(0.0)，GKSC算法是花费最小的，(2)随着距离阈值的增大，GKSC所花费的时间一直增大，而CKSC和LCC所花费的时间则是先增大再减小。这说明图7中所展示的三个算法的时间复杂度的特性。

在图7(a)中，当距离阈值被设为0.0时，三个算法的返回结果都是那些标签中含有多个关键字的结点。这是因为每一个这种结点都被看成是不同的几个结点；当距离阈值为6.0时，几乎所有的结点都被聚入了少数几个大的簇中；而随着距离阈值的增大，除了单结点簇外的结果数量先增大，然后再减小为1。图7中其它部分与图7(a)的情况基本相同。图7还说明了GKSC和CKSC的返回结果数量相同，而LCC略少。另外还计算了所有返回的簇的平均距离，其中GKSC和CKSC的结果相同，而LCC的稍大(仅仅在小数点后四位)。所以，GKSC和CKSC返回同样的结果(所有的最优簇)，而LCC返回了更少并且更大的结果，并与GKSC和CKSC的结果相差不大。

从图5中可以看出在关键字个数一定时，从DBLP中获得的平均关键字结点总数要多于从Treebank中获得的平均关键字结点数。但通过图6的比较可以看出，无论使用哪种聚类算法，在相应的情况下，对于Treebank所花费的聚类时间都要大于(有些是远大于)对DBLP所花费的时间，这说明了聚类算法的时间复杂度不只与关键字结点总数相关，还依赖于特定的文档结构以及实际的关键字结点的分布情况。当树的高度更大以及结构更加复杂时，聚类算法的时间花费也会增大。

除此之外，在实验中还实现了XKSearch^[2]中寻找SLCA的算法IL(Indexed Lookup)，并与之进行比较。根据XKSearch，IL的算法复杂度为O(|S₁|·log|S|)。它将所有的关键字结点按照包含关键字的情况分为一些关键字结点集(具有相同关键字的结点在同一个集合中)；|S₁|是其中最小的集合的结点数，而|S|是所有关键字结点的总数。图8是三个聚类算法和IL算法在DBLP上的时间花费比较(距离阈值为2.0)，在其它距离阈值下结果也类似。从图8中可以看出，IL的算法效率比任何一种聚类算法的效率都高，原因在于这两类算法的设计目标不同：IL仅仅是从所有关键字结点中找出一组特殊的结点，而聚类算法的目的则是在于根据一个距离阈值找到一个特定的关键字结点集合的一个划分。

因为本发明支持关键字之间的“OR”运算，因而通常情况下会得到更多结果。为了进一步进行说明，实验中选用特定的搜索结果来说明XKCluster和SLCA方法结果的异同。这里使用XMark^[14]数据集来进行两种方法结果的比较实验，因为XMark数据集的DTD中包含大量的递归元素。图9(a)是XMark的一个DTD片段。实验中先使用XMark提供的文档生成器生成一个XML文档，然后使用两种方法分别对该文档进行关键字搜索。图9(b)是该文档的一个文档片段。如果使用“Martin”和“Oscar”作为搜索的关键字，，则SLCA方法能够找出一个SLCA结点“text”，，然后可以依此返回以该结点为根的子树(是一封邮件的正文)。SLCA方法在选取结果时认为LCA相对最低的结果最优秀，但对于得到的所有结果却不能按照LCA的高低排序。所以即使提供了某种结果的扩展方法，用户也很难确定对哪个结果使用该方法，所以不能得到该邮件的其它信息(比如日期)。而只要距离阈值的大小设置合理，本发明的方法可以得到“mail”结点和“text”结点，从而能够得到更多的信息。实际在现实使用的文档中，这种情况经常发生。因为一封邮件的发送者和接收者的名字往往会在邮件正文中出现。另外，“keyword”元素会导致更多类似情况的出现，因为在DTD中，它直接指向自己形成递归。

参考文献

[1]V.Hristidis，Y.Papakonstantinou，and A.Balmin.Keyword proximity search onXML graphs.In ICDE，2003.

[2]Y.Xu，Y.Papakonstantinou.Efficient Keyword Search for Smallest LCAs in XMLDatabases.In SIGMOD，2005.

[3]Y.Li，C.Yu，and H.V.Jagadish.Schema-Free XQuery.In VLDB，2004.

[4]V.Hristidis，N.Koudas，Y.Papakonstantinou，and D.Srivastava.KeywordProximity Search in XML Trees.In IEEE Transactions on Knowledge and DataEngineering，2006

[5]S.Cohen，J.Mamou，Y.Kanza，and Y.Sagiv.XSEarch：A Semantic Search Enginefor XML.In VLDB，2003.

[6]L.Guo，F.Shao，C.Botev，and J.Shanmugasundaram.XRANK：Ranked Keyword Searchover XML Documents.In SIGMOD，2003.

[7]Z.Liu and Y.Chen.Identifying Meaningful Return Information for XML KeywordSearch.In SIGMOD，2007.

[8]G.Bhalotia，A.Hulgeri，C.Nakhe，S.Chakrabarti，and S.Sudarshan.Keywordsearching and browsing in database using BANKS.In ICDE，2002.

[9]V.Hristidis and Y.Papakonstantinou.Discover：Keyword search in relationaldatabases.In VLDB，2002.

[10]S.Agrawal，S.Chaudhuri，and G.Das.DBXplorer：A system for keyword-basedsearch over relational database.In ICDE，2002.

[11]H.He，H.Wang，J.Yang，and P.S.Yu.BLINKS：Ranked Keyword Searches on Graphs.In SIGMOD，2007.

[12]http://www.cs.washington.edu/research/xmldatasets/www/repository.html

[13]T.Feder，P.Hell，S.Klein，and R.Motwani.Complexity of graph partitionproblems.In SIGACT，1999.

[14]Xmark，http://monetdb.cwi.nl/xml/.

                                    表1

Claims (2)

1、一种基于语义距离模型的XML文档关键字搜索聚类方法，其特征在于具体步骤如下：

(1)定义用户提交的关键字，并将XML文档的关键字搜索语义定义为关键字之间的语义距离模型，并以此来表示用户的搜索意图；

(2)将关键字搜索的返回结果定义为关键字簇的最小组成树；

(3)XML文档树进行预处理；

(4)根据本发明提出的语义距离模型，选择使用如下三种聚类算法之一种进行XML关键字搜索：基于图的聚类算法、核心集驱动的聚类算法和松弛的核心集驱动聚类算法；

(5)根据排序模型，对搜索结果进行排序。

步骤(1)中将用户提交的关键字定义为一个包含t个关键字的集合L＝{k_i|i＝1，…，t}，XML文档定义为一棵XML文档树，具体如下：

定义1.XML文档树，将一颗XML文档树表示为一个8元组d＝(V，E，X，label(id)，pl(id₁，id₂)，depth(id)，dwcode(id)，lca(V′))，其中：

(1)V是树上所有结点的集合，并且每个结点都有唯一的标识符和Dewey编码；

(2)EV×V，是树上边的集合；

(3)label(id)为标签函数，用来获得标识为id的结点的标签，其中id∈V；

(4)XV是树上所有关键字结点的集合，所谓关键字结点即标签中包含关键字的结点；

(5)pl(id₁，id₂)函数，用来取得id₁和id₂两个结点之间的路径长度，其中id₁和id₂必须具有祖先后代关系，而此函数返回的结果为它们之间的路径上所包含的边的个数；

(6)depth(id)函数，用来获得标识为id的结点的深度(树的根的深度为1)，其中id∈V；

(7)dwcode(id)函数，用来获得标识为id的结点的Dewey编码，其中id∈V；

(8)lca(V′)函数，其中V′V是V的任意子集，函数返回V′中所有结点的最低公共祖先；

定义2.两个关键字结点之间的最短路径，两个关键字结点x_i和x_j的最短路径为结点x_i到lca({x_i，x_j})的路径加上结点x_j到lca({x_i，x_j})的路径；同时，用函数spl(x_i，x_j)来表示结点x_i和x_j的最短路径的长度，显然spl(x_i，x_j)＝pl(lca({x_i，x_j})，x_i)+pl(lca({x_i，x_j})，x_j)；

定义  两个关键字结点之间的语义距离，XML文档树上任意两个关键字结点之间的语义距离dis(x_i，x_j)被定义如下：

$\mathrm{dis}(x_i,x_j)=\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}---\left(1\right)$

在公式(1)中，分子和分母部分分别是两关键字结点间最短路径的长度和它们LCA的高度。

步骤(2)中，定义关键字结点的簇，根据关键字语义距离模型，将关键字结点集分成一组簇，簇的集合表示为C＝{C_i|i＝1，…，m}，其中，一个簇C_i是一组关键字结点的集合，C_iX，且 $\underset{i=1}{\overset{m}{\∪}}{C}_i=X;$

设定一个距离阈值ω来约束簇的大小，簇中任意两个关键字结点之间的距离小于等于ω；

定义最优簇，给定一个距离阈值ω，任一个关键字集合C_iX被称为最优簇，当且仅当：(1)x_i，x_j∈C_i满足dis(x_i，x_j)≤ω；(2)x_a，x_a∈X且x_aC_i，x_b∈C_i满足dis(x_a，x_b)＞ω；

将返回结果定义为簇的“最小组成树”，具体如下：

C中每个簇C_i的最小组成树定义为：以lca(C_i)为根，以descendants(C_i)中的所有结点为叶子的树；其中descendants(C_i)函数返回C_i中所有在C_i内不含有任何后代的关键字结点的集合，即就是C_i的最小组成树是从lca(C_i)到descendants(C_i)中所有结点的；

步骤(3)中，对XML文档树进行预处理的步骤如下：

(1)使用Dewey编码为整棵XML文档树进行编码；

(2)为所有的关键字建立倒排索引表；

(3)对于深度为h的XML文档树，建立一个包含有h个有序关键字结点列表的层次型数据结构H；其中每一个层次是将XML文档树上一组处于同一高度的多个结点按照文档访问顺序组成一个序列I，x_i是其中的任一个结点；

(4)先序遍历XML文档树，每遇到一个标签含有关键字的结点，将它加入相应层次的列表的尾部；

步骤(5)中所述排序步骤如下：

(1)首先根据每个簇含有关键字的情况进行分组，所有含有相同关键字种类个数的簇被分入一组，对组进行排序，含有越多关键字种类的组排得越靠前；

(2)对于同一组内的簇，计算它们的平均距离，平均距离越小的簇在组内排得越靠前；对所有的簇排好序后，为每个簇生成一个最小组成树，并按照顺序将它们返回给用户；

(3)单结点簇被排到整个结果序列的最后；

其中，所述平均距离的定义如下：

对于结果簇集合C中任一个簇C_i，它的平均距离dis_mean为它所包含的所有结点之间两两距离的平均值，假设m是C_i所包含的结点的个数，则C_i的平均距离如公式(2)所示

${\mathrm{dis}}_{\mathrm{mean}}\left(C_i\right)=\left\{\begin{array}{c}\frac{\underset{x_i,x_j\∈C_i;x_i\≠x_j}{\mathrm{\Σ}}\mathrm{dis}(x_i,x_j)}{2C_m^2},m>1\\ \∞,m=1\end{array}\right.---\left(2\right).$

2、根据权利要求1所述的基于语义距离模型的XML文档关键字搜索聚类方法，其特征在于所述步骤(4)中，三种聚类算法具体步骤如下：

(一)基于图的关键字搜索聚类算法的具体步骤如下：

(1)从上到下按层次访问H中的结点，在每一层的列表中，从左到右遍历，对于当前访问结点，计算它和同层右边以及下面的某些邻居的距离；

(2)对于更低层次的结点，首先确定有多少层次的结点需要被考虑；给定一个ω，距离公式必须满足 $\mathrm{dis}(x_i,x_j)=\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}\≤\mathrm{\ω},$ 又由于depth(x_i)≥depth(lca({x_i，x_j}))，所以 $\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(x_i\right)}\≤\frac{\mathrm{spl}(x_i,x_j)}{\mathrm{depth}\left(\mathrm{lca}\left(\right\{x_i,x_j\left\}\right)\right)}\≤\mathrm{\ω}$ 成立，也就是说spl(x_i，x_j)≤depth(x_i)×ω，所以floor(depth(x_i)·ω)是x_i下面必须考虑的层次的数目，其中floor函数表示向下取整；

(3)计算出所需要考虑的层次数目后，对于x_i下方floor(depth(x_i)·ω)层中的每一层，首先找到x_i的后代在该层中的位置，再从该位置向左遍历直至距离超出阈值，在这一层中，其它结点都不需要参与考虑；当x_i是所属层中的第一个结点时，使用二分法去寻找它在floor(depth(x_i)·ω)个低层次列表中后代结点的位置，并且用指针记录下这些位置；而当x_i不是第一个结点时，只从那些记录的位置开始向右寻找后代结点的位置，之后再修改指针到当前位置；

(4)每次计算两个结点的距离时，如果小于或等于距离阈值，则将该两个结点用边连接起来，并且记录下距离作为该边的权；

(5)上一步结束后，可以得到一个加权的无向图，然后再将图分解得到所有的最大完全字图，从而得到结果簇；

(二)核心集驱动的聚类算法的步骤如下：

定义核心集，对于距离阈值ω来说，任一个关键字集合C_oX，如果它所包含的关键字结点中任意两者之间的距离都小于或等于ω，则C_o被称为一个核心集(core)；

定义原始核心集，H中的一个结点集合C_o’被称为一个原始核心集(core origin)，当且仅当：(1)C_o’是一个核心集；(2)C_o’中的结点都处于H的同一层次；(3)在该层次中不存在一个核心集C_o使得C_o’C_o；

(1)首先遍历H，将H中的结点分成一些核心集，对于H的每一层，具体的做法是：创建一个空集，将该层第一个结点加入，从第二个结点开始往后遍历，计算第一个结点与遍历当前结点之间的距离；如果小于等于ω则将之加入集合；当遇到距离超出ω的第一个结点时，再创建一个空集，以该结点为集合中第一个结点继续遍历，直至该层中所有结点都已遍历完；一个原始核心集所包含的是H上同一层次中相邻的一组结点，所以，{x_l，…，x_r}是一个原始核心集；

(2)再寻找原始核心集周围的核心集，求出包含这些原始核心集的最优簇，当找出{x_l，…，x_r}在所有层次上需要考虑的核心集后，在每一层取一个核心集组成一个核心集的集合，在该集合内寻找包含{x_l，…，x_r}的最优簇；

(三)松驰的核心集驱动聚类算法的具体步骤如下：

(1)首先遍历层次型数据结构H，得到一组原始核心集；

(2)对于H中的每一层建立两个列表：头结点列表HNL和尾结点列表TNL；其中，HNL和TNL分别按顺序存放该行中所有原始核心集的第一个和最后一个结点；

(3)对于每个原始核心集C_o’，寻找其它所有层次中的一些原始核心集，这些原始核心集中存在结点到所有C_o’中结点的距离都小于等于ω；

(4)找到这些原始核心集后，将它们合并到C_o’中形成一个结果集。

Images