全文检索、数据挖掘、推荐引擎系列5---文章术语向量表示法

无论是要进行全文检索，还是对文章进行自动聚类分析，都需要将文章表示为术语向量（Term Vector），在Lucene内部就是通过术语向量来对文章进行索引和搜索的，但是Lucene没有向外提供合适的术语向量计算接口，所以对术语向量计算还必须我们自己来做。

术语向量解述

众所周知，一篇文章由一个个的单词组成，我们在进行文本处理时，首先进行中文分词，包括去除“的、地、得”等常用停止词，对关键词加上同义词，如缩写和全称，如果是英文可能还需要变为小写，去除复数和过去分词等，可能还需要提取词根，总之经过上述步聚的预处理，文章将变成由一系列单词组成的字符串数组。

对一系统中的每一篇文章，我们首先计算每个单词的出现频率（TF：TermFrequency），即该单词出现的次数除以文章总单词数，然后统计这个单词的反比文档频率（IDF：Inverse Document Frequency），在所有文章中出现的次数，并用该数除文章总数，即总文章数除以出现该单词文章的数目。由上面的定义可以看出，单词越重要，他的单词出现频率TF就越高，单词越是只在这篇文章中出现，很少在其它文章中出现，那该单词越对本篇文章具有重要意义。通过一定的公式，可以计算出每个单词的对每篇文章的权重，这样所有单词加上其对应的权重，就形成了一个多维术语向量。

计算TF*IDF

对于术语向量的计算方法，目前还没有特别成熟的算法，现在常用的只是一些经验算法，一些文章中提出的号称更加准确的算法，还没有经过实际验证。我们在这里采用的是当前最常用的算法，根据实际需要对这些算法进行修正也是相当简单的。

首先系统需要维护几个全局变量：总文章数、系统中所有单词以及其在文章中出现的次数

// 因为单词出现在文章的不同位置重要性不同，可以设置不同的权重

public final static int TITLE_WEIGHT = 1;

public final static int KEYWORD_WEIGHT = 1;

public final static int TAG_WEIGHT = 1;

public final static int ABCT_WEIGHT = 1;

public final static int BODY_WEIGHT = 1;

private static int docsNum = 0; // 目前系统中的总文档数，将来需要存在数据库中

private static Map<String, Integer> wordDocs = null; // 每个单词在所有的每篇文章中出现的文章个数（文章数）

private static Vector<Integer> termNumDoc = null; // 每篇文章的总单词数

private static Vector<Vector<TermInfo>> termVectors = null; // 每篇文章的术语向量表示

然后是对一段文本产生术语原始术语向量的程序，如下所示：

/**

* 一篇文章分为标题、关键字、摘要、标志、正文几个部分组成，每个部分的单词具有不同的权重，通过

* 本函数进行中文分词，同时生成该部分的术语向量

* @param text 需要处理的文本

* @param termArray 术语向量

* @param weight 单词在本部分的权重

* @return 本部分的单总数（用于计算单词出现频率TF）

*/

private static int procDocPart(String text, Vector<TermInfo> termArray, int weight) {

Collection<String> words = FteEngine.tokenize(text);

Iterator<String> itr = words.iterator();

String word = null;

TermInfo termInfo = null;

int termMount = 0;

while (itr.hasNext()) {

word = itr.next();

if (termArray.contains(word)) {

termInfo = termArray.get(termArray.indexOf(word));

termInfo.setMountPerDoc(termInfo.getMountPerDoc() + weight);

} else {

termInfo = new TermInfo();

termInfo.setMountPerDoc(weight);

termInfo.setTermStr(word);

termInfo.setRawWeight(0.0);

termInfo.setWeight(0.0);

termArray.add(termInfo);

}

termMount += weight;

}

return termMount;

}

下面是求出TF*IDF然后进行归一化生成最终术语向量的程序：

/**

* 对标题、关键字、标记、摘要、正文采用迭加方式生成术语向量

* @param docIdx 文档编号，为-1时表示新加入的文档

* @param text 需要处理的文本

* @param weight 本段文本单词出现的权重

* @return 文档编号

*/

public static int genTermVector(int docIdx, String text, int weight) {

Vector<TermInfo> termVector = null;

if (docIdx < 0) {

docIdx = docsNum;

termNumDoc.add(0);

termVector = new Vector<TermInfo>();

termVectors.add(termVector);

docsNum++;

}

termVector = termVectors.elementAt(docIdx);

int termMount = procDocPart(text, termVector, weight);

termNumDoc.set(docIdx, termNumDoc.elementAt(docIdx).intValue() + termMount);

// 计算所有术语的IDF

TermInfo termInfo = null;

String termStr = null;

Iterator<TermInfo> termInfoItr = termVector.iterator();

// 计算每个单词在文章中出现的篇数

while (termInfoItr.hasNext()) {

termInfo = termInfoItr.next();

termStr = termInfo.getTermStr();

if (wordDocs.get(termStr) != null) {

wordDocs.put(termStr, wordDocs.get(termStr).intValue() + 1);

} else {

wordDocs.put(termStr, 1);

}

termInfo.setTf(termInfo.getMountPerDoc() / ((double)termNumDoc.elementAt(docIdx).intValue()));

}

Iterator<Vector<TermInfo>> docItr = termVectors.iterator();

// 计算TF*IDF

double rwPSum = 0.0;

while (docItr.hasNext()) {

termVector = docItr.next();

termInfoItr = termVector.iterator();

rwPSum = 0.0;

while (termInfoItr.hasNext()) {

termInfo = termInfoItr.next();

termInfo.setRawWeight(termInfo.getTf() * Math.log(((double)docsNum) /

wordDocs.get(termInfo.getTermStr()).intValue()));

rwPSum += termInfo.getRawWeight() * termInfo.getRawWeight();

}

// 对TF*IDF进行归一化

termInfoItr = termVector.iterator();

while (termInfoItr.hasNext()) {

termInfo = termInfoItr.next();

termInfo.setWeight(termInfo.getRawWeight() / Math.sqrt(rwPSum));

}

}

return docIdx;

}

文章相似度计算

文章的相似度就是要计处两篇文章对应的术语向量的距离，也就是对应各个术语归一化后的TF*IDF的权重差的平方合再开发，类似于二维矢量距离的计算，具体实现代码如下所示：

/**

* 计算术语向量的距离，该值小则表明两篇文章相似度高

* @param termVector1

* @param termVector2

* @return 距离

*/

public static double calTermVectorDist(Collection<TermInfo> termVector1, Collection<TermInfo> termVector2) {

double dist = 0.0;

Vector<TermInfo> tv1 = (Vector<TermInfo>)termVector1;

Vector<TermInfo> tv2 = (Vector<TermInfo>)termVector2;

Hashtable<String, TermInfo> tv2Tbl = new Hashtable<String, TermInfo>();

Iterator<TermInfo> tvItr = null;

TermInfo termInfo = null;

TermInfo ti2 = null;

double[] weights = new double [tv2.size()];

int idx = 0;

// 初始化数据

tvItr = tv2.iterator();

while (tvItr.hasNext()) {

termInfo = tvItr.next();

//weights[idx++] = termInfo.getWeight();

tv2Tbl.put(termInfo.getTermStr(), termInfo);

}

//

tvItr = tv1.iterator();

while (tvItr.hasNext()) {

termInfo = tvItr.next();

ti2 = tv2Tbl.get(termInfo.getTermStr());

if (ti2 != null) {

dist += (termInfo.getWeight() - ti2.getWeight()) * (termInfo.getWeight() - ti2.getWeight());

ti2.setWeight(0.0);

} else {

dist += termInfo.getWeight() * termInfo.getWeight();

}

}

tvItr = tv2Tbl.values().iterator();

while (tvItr.hasNext()) {

termInfo = tvItr.next();

System.out.println("######: " + termInfo.getTermStr() + "=" + termInfo.getWeight() + "!");

dist += termInfo.getWeight() * termInfo.getWeight();

}

System.out.println();

return Math.sqrt(dist);

}

下面对以下三句话进行计算：

Java语言编程技术详解

C++语言编程指南

同性恋网站变身电子商务网站

计算的术语向量值为：

java:0.5527962688403749

语言:0.20402065516569604

编程:0.20402065516569604

技术:0.5527962688403749

详解:0.5527962688403749

############## doc2 ############

c:0.6633689723434504 （注：我们的词典中没有C++）

语言:0.24482975009584626

编程:0.24482975009584626

指南:0.6633689723434504

############## doc3 ############

同性恋:0.531130184813292

网:0.196024348194679

站:0.196024348194679

变身:0.531130184813292

电子商务:0.531130184813292

网:0.196024348194679

站:0.196024348194679

然后计算距离为：

第一篇与第二篇：1.3417148340558687

第一篇与第三篇：1.3867764455130116

因此通过计算结果系统会认为第一篇和第二篇更接近，实际情况也是如此，因为第一篇和第二篇间有两个单词是相同的，而第一篇和第三篇间则没有任何相同的地方。