使用VSM计算文档相似度的一个程序示例

最新推荐文章于 2021-02-28 13:55:33 发布
最新推荐文章于 2021-02-28 13:55:33 发布
阅读量5.1k 收藏 9
点赞数
分类专栏： IR 文章标签： 文档 string null integer import 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neo_2011/article/details/6940455
版权

以前课程作业写的一个小程序，复习一下知识点……


VSM（vector space model，向量空间模型）http://en.wikipedia.org/wiki/Vector_space_model

本例中使用的TF-IDF权重模型公式为sim(q,d)等于



TFdoc表示文档中词项出现的次数，TFq表示查询中词项出现的次数，df(w)表示出现词项的文档数，df(w)越小，则对应词项的IDF区分度越高。

程序主要涉及到预处理语料，设计统计词频文档数的数据结构，计算相似度。

一段语料的例子：

19980101-01-001-007/m  １９９７年/t  ，/w  是/v  中国/ns  发展/vn  历史/n  上/f  非常/d  重要/a  的/u  很/d  不/d  平凡/a  的/u  一/m  年/q  。/w  中国/ns  人民/n  决心/d  继承/v  邓/nr  小平/nr  同志/n  的/u  遗志/n  ，/w  继续/v  把/p  建设/v  有/v  中国/ns  特色/n  社会主义/n  事业/n  推向/v  前进/v  。/w  [中国/ns  政府/n]nt  顺利/ad  恢复/v  对/p  香港/ns  行使/v  主权/n  ，/w  并/c  按照/p  “/w  一国两制/j  ”/w  、/w  “/w  港人治港/l  ”/w  、/w  高度/d  自治/v  的/u  方针/n  保持/v  香港/ns  的/u  繁荣/an  稳定/an  。/w  [中国/ns  共产党/n]nt  成功/a  地/u  召开/v  了/u  第十五/m  次/q  全国/n  代表大会/n  ，/w  高举/v  邓小平理论/n  伟大/a  旗帜/n  ，/w  总结/v  百年/m  历史/n  ，/w  展望/v  新/a  的/u  世纪/n  ，/w  制定/v  了/u  中国/ns  跨/v  世纪/n  发展/v  的/u  行动/vn  纲领/n  。/w
最初我是用java字符串的正在表达式处理的，主要的一行代码是

str =str =str.replaceAll("(/|]|\\[)[A-Za-z]{0,2}", "") + '\n';

整个java程序15行。后来学习了一点sed，该预处理可以只用一条命令完成

sed -r 's/(\/|\[|\])[A-Za-z]{0,2}//g' 原始语料.txt > 原始语料.edited.txt


准备一个中文停用词表。


主要的数据结构： 

import java.util.*;

public class TermInfo {
	int totalCount;
	Map<String, Integer> inDocInfo;
	public TermInfo() {
		totalCount = 0;
		inDocInfo = new HashMap<String, Integer>();
	}
}

import java.util.*;

public class ArticleInfo {
	int length;
	Vector<String> termVec;
	public ArticleInfo() {
		length = 0;
		termVec = new Vector<String>();
	}
}

import java.util.*;

public class ArticleSim {
	TreeMap<String, Double> dKeySim;
	public ArticleSim() {
		dKeySim = new TreeMap<String, Double>();
	}
}


计算相似度的主程序：

	import java.io.*;
	import java.util.*;

	public class Similarity extends ArticleInfo {
		private static final int ARTICLE_KEY_LENGTH = 15; // 文档key的长度
		private static final double THRESHOLD = 0.2; // 文档长度归一化阀值
		private static double averageArticleLen; // 文档平均长度
		private static Set<String> stopwordSet; // 停用词集合
		private static TreeMap<String, String> articleMap; // 文档key与内容的映射集
		private static TreeMap<String, TermInfo> termInfoMap; // 词项与其相关统计信息的映射集
		private static TreeMap<String, ArticleInfo> articleInfoMap; // 文档key与其相关统计信息（长度、词项集）的映射集
		private static TreeSet<String> termIntersection; // 文档词项交集

		public static void main(String args[]) {
			setStopwordSet();
			Similarity s = new Similarity();
			articleMap = s.setArticleMap();
			termInfoMap = s.setTermInfoSet();
			articleInfoMap = s.setArticleInfoMap();
			long sTime = System.currentTimeMillis();
			String qKey = null;
			qKey = articleMap.firstKey();
			for (int i = 0; i < 10; i++) {
				outputAnArticleSimArray(qKey);
				qKey = articleMap.higherKey(qKey);
			}
			outputAnArticleSimArray("19980101-03-012");
			long eTime = System.currentTimeMillis();
			System.out.println("Computing first 100 Articles' Similarity used "
					+ (eTime - sTime) + "ms" + '\n');
			// outputAnArticleSimArray("19980101-01-001");
			// double similarity =
			// s.computeSimilarity("19980101-01-001","19980101-01-002");
			// System.out.println(similarity);
			// sim.intersectTerm("19980101-01-001","19980101-01-002");
		}

		public static void setStopwordSet() {
			long sReadTime = System.currentTimeMillis();
			BufferedReader bufferedIn = null;
			String str = "";
			stopwordSet = new HashSet<String>();
			try {
				bufferedIn = new BufferedReader(new FileReader(
						"ChineseStopword.txt"));
				while ((str = bufferedIn.readLine()) != null) {
					stopwordSet.add(str);
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			long eReadTime = System.currentTimeMillis();
			System.out.println("stopword count is " + stopwordSet.size());
			System.out
					.println("Reading the Chinese stopwords into the Set container used "
							+ (eReadTime - sReadTime) + "ms" + '\n');
		}

		public TreeMap<String, String> setArticleMap() {
			long sReadTime = System.currentTimeMillis();
			BufferedReader bufferedIn = null;
			String str = "";
			TreeMap<String, String> articles = new TreeMap<String, String>();
			try {
				bufferedIn = new BufferedReader(new FileReader("Edited.txt"));
				while ((str = bufferedIn.readLine()) != null) {
					if (str.length() > 0) {
						String articleKey = str
								.substring(0, ARTICLE_KEY_LENGTH);// 前15位字符串做Key
						String articleContent = str
								.substring(ARTICLE_KEY_LENGTH + 4);
						if (articles.isEmpty()
								|| !articles.containsKey(articleKey))
							articles.put(articleKey, articleContent);
						else {
							String tempStr = articles.get(articleKey)
									+ articleContent;
							articles.put(articleKey, tempStr);
						}
					}
				}
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			long eReadTime = System.currentTimeMillis();
			System.out.println("Article count is " + articles.size());
			System.out.println("Building the articleMap used "
					+ (eReadTime - sReadTime) + "ms" + '\n');
			return articles;
		}

		public TreeMap<String, TermInfo> setTermInfoSet() {
			long sTime = System.currentTimeMillis();
			TreeMap<String, TermInfo> terms = new TreeMap<String, TermInfo>();// 新建TreeMap对象
			String currentArticleKey = articleMap.firstKey();// 取文档集最小的键值
			while (currentArticleKey != null) {
				String currentArticleContent = articleMap
						.get(currentArticleKey);// 文档正文内容
				int len = 0;// 文档中非空字符数，没有区分字符和汉字，没有排除停用词
				for (int i = 0; i != currentArticleContent.length() - 1;) {// 遍历文档字符串
					String str = currentArticleContent.substring(i, i + 1);
					String tempTerm = "";
					if (str.equals(" ")) {
						i++;
						continue;
					}
					while (!str.equals(" ")) {
						tempTerm += str;
						len++;
						i++;
						str = currentArticleContent.substring(i, i + 1);
					}
					if (stopwordSet.contains(tempTerm))
						continue;// 遇到停用词，换下一个非空词项
					else {
						if (!terms.keySet().contains(tempTerm)) {// 加入新词项
							TermInfo aTermInfo = new TermInfo();
							aTermInfo.totalCount = 1;
							aTermInfo.inDocInfo.put(currentArticleKey, 1);
							terms.put(tempTerm, aTermInfo);
						} else {// 更新词项信息
							TermInfo bTermInfo = terms.get(tempTerm);
							bTermInfo.totalCount++;
							if (bTermInfo.inDocInfo.get(currentArticleKey) == null)
								bTermInfo.inDocInfo.put(currentArticleKey, 1);
							else {
								Integer tempInDocCount = bTermInfo.inDocInfo
										.get(currentArticleKey) + 1;
								bTermInfo.inDocInfo.put(currentArticleKey,
										tempInDocCount);
							}
							terms.put(tempTerm, bTermInfo);
						}
					}
				}
				currentArticleKey = articleMap.higherKey(currentArticleKey);// 取下一个严格高于当前键值的最小键值
			}
			long eTime = System.currentTimeMillis();
			System.out.println("Term total count is " + terms.size());
			System.out.println("Building the termInfoMap used "
					+ (eTime - sTime) + "ms" + '\n');
			return terms;
		}

		public TreeMap<String, ArticleInfo> setArticleInfoMap() {
			long sTime = System.currentTimeMillis();
			TreeMap<String, ArticleInfo> articleInfos = new TreeMap<String, ArticleInfo>();// 新建TreeMap对象
			String currentArticleKey = articleMap.firstKey();// 取文档集最小的键值
			int allArticleLength = 0;
			int len = 0;
			while (currentArticleKey != null) {
				String currentArticleContent = articleMap
						.get(currentArticleKey);// 文档正文内容
				if (articleInfos.get(currentArticleKey) == null) {
					len = 0;
				} else
					len = articleInfos.get(currentArticleKey).length;// 文档中非空字符数，没有区分字符和汉字，没有排除停用词
				for (int i = 0; i != currentArticleContent.length() - 1;) {// 遍历文档字符串
					String str = currentArticleContent.substring(i, i + 1);
					String tempTerm = "";
					if (str.equals(" ")) {
						i++;
						continue;
					}
					while (!str.equals(" ")) {
						tempTerm += str;
						len++;
						i++;
						str = currentArticleContent.substring(i, i + 1);
					}
					if (stopwordSet.contains(tempTerm))
						continue;// 遇到停用词，换下一个非空词项
					else {
						if (!articleInfos.keySet().contains(currentArticleKey)) {// 加入新词项
							ArticleInfo anArticleInfo = new ArticleInfo();
							anArticleInfo.length = len;
							anArticleInfo.termVec.add(tempTerm);
							articleInfos.put(currentArticleKey, anArticleInfo);
						} else {// 更新词项信息
							ArticleInfo bArticleInfo = articleInfos
									.get(currentArticleKey);
							bArticleInfo.length = len;
							bArticleInfo.termVec.add(tempTerm);
							articleInfos.put(currentArticleKey, bArticleInfo);
						}
					}
				}
				allArticleLength += articleInfos.get(currentArticleKey).length;
				currentArticleKey = articleMap.higherKey(currentArticleKey);// 取下一个严格高于当前键值的最小键值
			}
			long eTime = System.currentTimeMillis();
			averageArticleLen = allArticleLength / articleMap.size();
			System.out.println("Building the articleInfoMap used "
					+ (eTime - sTime) + "ms" + '\n');
			return articleInfos;
		}

		public static void intersectTerm(String q, String d) {// 求词项集合交集
		// long sTime = System.currentTimeMillis();
			termIntersection = new TreeSet<String>();
			TreeSet<String> tempSet = new TreeSet<String>();
			if (articleInfoMap.get(q) == null || articleInfoMap.get(d) == null) {
				System.out.println("Invalid article key.");
				System.exit(0);
			}
			for (int i = 0; i != articleInfoMap.get(q).termVec.size(); i++)
				tempSet.add(articleInfoMap.get(q).termVec.get(i));
			for (int i = 0; i != articleInfoMap.get(d).termVec.size(); i++) {
				boolean flag = tempSet.contains(articleInfoMap.get(d).termVec
						.get(i));
				if (flag == true) {
					termIntersection.add(articleInfoMap.get(d).termVec.get(i));
				}
			}
			// long eTime = System.currentTimeMillis();
			// System.out.println("文档"+q+"和文档"+d+"的词项交集有"+termIntersection.size()+"项。");
			// System.out.println(termIntersection);
			// System.out.println("Intersecting two termVecs used "+(eTime -
			// sTime)+"ms"+'\n');
			// return termIntersection;
		}

		public static double computeSimilarity(String qKey, String dKey) {// 计算两文档间的相似度，文档Key为参数
		// long sTime = System.currentTimeMillis();
			double sim = 0;
			intersectTerm(qKey, dKey);
			Iterator<String> it = termIntersection.iterator();
			while (it.hasNext()) {
				String commonTerm = it.next();
				int cwd = termInfoMap.get(commonTerm).inDocInfo.get(dKey);
				int cwq = termInfoMap.get(commonTerm).inDocInfo.get(qKey);
				int dfw = termInfoMap.get(commonTerm).inDocInfo.size();
				sim += (1 + Math.log(1 + Math.log(cwd)))
						/ (1 - THRESHOLD + THRESHOLD
								* articleInfoMap.get(dKey).length
								/ averageArticleLen) * cwq
						* Math.log((articleMap.size() + 1) / dfw);
			}
			// long eTime = System.currentTimeMillis();
			// System.out.println("Computing a similarity used "+(eTime -
			// sTime)+"ms"+'\n');
			// System.out.println("Sim is "+sim+'\n');
			return sim;
		}

		public static void outputAnArticleSimArray(String articleKey) {
			// long sTime = System.currentTimeMillis();
			TreeMap<String, Vector<ArticleSim>> articleSimArray = new TreeMap<String, Vector<ArticleSim>>();
			Vector<ArticleSim> anArticleSimVec = new Vector<ArticleSim>();
			double sim = 0;
			String qKey = articleKey;
			String dKey = articleMap.firstKey();
			while (dKey != null) {
				ArticleSim anArticleSim = new ArticleSim();
				if (dKey.equals(qKey))
					sim = 0;
				else
					sim = computeSimilarity(qKey, dKey);
				anArticleSim.dKeySim.put(dKey, sim);
				anArticleSimVec.add(anArticleSim);
				articleSimArray.put(qKey, anArticleSimVec);
				dKey = articleMap.higherKey(dKey);
			}
			// long eTime = System.currentTimeMillis();
			// System.out.println("Computing an ArticleSimArray used "+(eTime -
			// sTime)+"ms"+'\n');
			int index = 0;
			dKey = articleMap.firstKey();
			for (; dKey != null;) {
				System.out.println(qKey
						+ "->"
						+ dKey
						+ " = "
						+ articleSimArray.get(qKey).get(index).dKeySim
								.get(dKey));
				dKey = articleMap.higherKey(dKey);
				index++;
			}
		}
	}



neo_2011
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
向量空间模型(VSM)在文档相似度计算上的简单介绍
Felomeng的技术博客
03-25 4万+
C#实现在：http://blog.csdn.net/Felomeng/archive/2009/03/25/4023990.aspx向量空间模型（VSM：Vector space model）是最常用的相似度计算模型，在自然语言处理中有着广泛的应用，这里简单介绍一下其在进行文档间相似度计算时的原理。假设共有十个词：w1，w2，......，w10，而共有三篇文章，d1，d2和d3。统
向量空间模型(VSM) (转)
weixin_30664051的博客
01-07 451
向量空间模型将文档映射为一个特征向量V(d)=(t1,ω1(d)；…；tn, ωn(d))，其中ti(i=1,2, …,n)为一列互不雷同的词条项，ωi(d)为ti在d中的权值, 一般被定义为ti在d中出现频率tfi(d)的函数，即 。 在信息检索中常用的词条权值计算方法为 TF-IDF 函数，其中N为所有文档的数目，ni为含有词条ti的文档数目。TF-IDF公式有很多变种，下面是一个常用...
vsm模型计算文本相似度
03-29
1.采用经典的vsm模型实现的文本相似度计算。 2.采用中科院ictclas的开源分词系统 3.包含全部实现源码
向量空间模型（VSM）一种文本相似度算法
hzq20081121107的专栏
02-17 1091
转自：http://blog.sina.com.cn/s/blog_a1304cff0101aj29.html 由于工作需要，我需要判断一篇文章是否是你喜欢的文章。     这涉及到文本分析，有一个简单的方法可供参考。向量空间模型（VSM）算法。     在该方法中，我们把一篇文章抽象成一个向量。     假设向量由n个词组成，每个词的权重是kn。假设文章D是你喜欢的文
文档排序--相似度模型--VSM
约定的博客
08-14 9692
说明：文章内容来源于课程视频和课程ppt。我只学习了课程没有做习题。文章不是翻译，是我对课程的理解。 　上文提到文档排序函数是TR的核心。文档排序函数的实现有几种思路，其中一种是基于相似度的模型。这种模型具体是用空间向量模型(Vector Space Model)实现。这篇文章就介绍VSM。 VSM概念 什么是VSM 　 　VSM定义了两点。 　第一，用词向量(term v...
基于Hadoop的文本相似度计算
06-11
在大数据处理领域，Hadoop是一个广泛使用的开源框架，它提供了分布式存储（HDFS）和分布式计算（MapReduce）的能力，使得处理大规模数据变得更加高效。基于Hadoop的文本相似度计算是一个重要的应用，常用于信息检索...
VSM信息检索模型（向量空间模型）
01-13
在本项目中，我们将探讨VSM的实现细节，包括文档表示、相似度计算以及使用的两种主要方法——余弦相似度（Cosine Similarity）和TF-IDF算法。 首先，让我们了解VSM的基本概念。在VSM中，每个文档被视为一个向量，这...
VSM模型构建样例项目文件
05-31
5. **应用示例**：这个VSM模型样例项目可能包括一个简单的应用，如查询文档的相关性，或者找出与某个主题最相关的文档。它可能通过加载分词处理后的数据，去除停用词，然后使用TF-IDF转换，最后计算查询向量与其他...
vsm.zip_Information Retrival_vector_vector space model_vsm_zip
09-21
在VSM中，每个文档或查询被视为一个向量，向量的维度对应于词汇表中的不同词项，向量的每个分量表示词项在文档或查询中出现的频率或权重。这种表示方法使得我们可以使用数学上的距离度量（如欧氏距离、余弦相似度等...
vsm向量空间模型java实现（源码）
12-24
在VSM中，每个文档或查询被视为一个由词项构成的向量，每个词项是向量的一个维度，而词项的频率决定了对应维度的权重。通过计算两个向量之间的余弦相似度，可以评估文档与查询的相关性。 **Java实现VSM** Java作为...
vsm程序，用于文本预处理，分类使用
03-28
文本预处理，先进行向量化，编程向量形式进行后期处理。本文是C++程序，实现文本向量化
向量空间模型vsm的c++和java实现
04-09
向量空间模型vsm的c++和java实现，很经典。
基于Python实现VSM余弦相似度计算
05-30
用2.7版本Python实现比较2个文档的相似度计算，采用余弦相似度方法，main函数中的fileName1和fileName2是自己构造的数据集，把这几个文档放在一起就可以运行。
简单向量空间模型VSM算法的实现
07-22
简单向量空间模型可用于文档相似度的计算，也可以用于检索信息，配有详细的注释
机器学习实验02 VSM模型构建
LAZYPET BLOG
06-22 960
一、实验目的和内容 目的： 1、把对象（这里是文档）用向量空间的形式表现出来 内容： 1、 读取input文档和StopWords文档并转为数组变量存储 2、 降维 a 处理停用词 b 处理垃圾词 3、 计算词频（TF） 4、 计算逆文档频率（NTF） 5、 计算TF-NTF值 6、 表示结果 7、 完整代码 1、读取input文档和StopWords文档并转为数组变量存储 ( 这里我是用nodejs环境 ) 直接用nodejs的fs模块即可，用readFile读取文件 代码如下 fs.readFile("
向量空间模型算法( Vector Space Model )
weixin_43184636的博客
01-16 8687
概念介绍 向量空间模型（VSM：Vector Space Model）由Salton等人于20世纪70年代提出，并成功 地应用于文本检索系统。 VSM概念简单，把对文本内容的处理简化为向量空间中的向量运算，并且它以空间上的相似 度表达语义的相似度，直观易懂。当文档被表示为文档空间的向量，就可以通过计算向量之间 的相似性来度量文档间的相似性。文本处理中最常用的相似性度量方式是余弦距离。 M个无序...
机器学习——VSM（覃秉丰）
Liu Feng's Blog
08-07 2087
SVM基础知识： 1、发展历史： 总结：SVM使用不是很多了，但也不是完全被淘汰了，不是特别感兴趣不用太过深入地研究 2、原理： 使得分界超平面距离两个类别之间的距离最大化 基础知识——向量内积： 支持向量（SVM） 相关推导： d越大越好，就是指||W||越小越好 凸优化问题 广义拉格朗日乘子法 进一步转换为对偶问题 3. SVM简单程序（使用sklearn） SVM算法比较麻烦，一般不会去复写源代码，调用封装好的库就行了 from sklearn import sv
VSM算法
压缩疯雷的博客
09-10 1204
VSM Vector Space Model 向量空间模型算法 这个算法用于文档排名
vsm特征提取java_java三大特征
weixin_42315706的博客
02-28 70
typora-root-url: imgjava八大类型面向对象的三个基本特征：封装，继承，多态；封装：将属性私有化，不允许外部数据直接访问，并设置相应的方法对属性进行设置和读取，从而实现对属性访问的限制。这种限制属性访问的操作叫做封装。main方法中运行测试，main方法 是程序的入口对象创建过程理解对象创建过程，区分构造方法和普通方法访问控制私有访问级别(private)只能在本类中通过调用方...
基于vsm模型的文本相似度检查软件的设计与实现.doc
最新发布
06-25
"基于vsm模型的文本相似度检查软件的设计与实现" 本文档主要介绍了基于向量空间模型...该文详细阐述了一个基于VSM模型的文本相似度检查软件的设计思路、实现方法和系统测试，对于理解和构建此类系统提供了宝贵的参考。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值