余弦定理的应用：基于文字的文本类似度计算

时间 2019-11-13

标签余弦定理应用基于文字文本类似计算繁體版

原文原文链接

最近因为工做项目，须要判断两个txt文本是否类似，因而开始在网上找资料研究，由于在程序中会把文本转换成String再作比较，因此最开始找到了这篇关于距离编辑算法 Blog写的很是好，受益不浅。 html

因而我决定把它用到项目中，来判断两个文本的类似度。但后来实际操做发现有一些问题：直接说就是查询一本书中的类似章节花了我七、8分钟；这是我不能接受…… java

因而停下来仔细分析发现，这种算法在此项目中不是特别适用，因为要判断一本书中是否有相同章节，因此每两个章节之间都要比较，若一本书书有x章的话，这里需对比x(x-1)/2次；而此算法采用矩阵的方式，计算两个字符串之间的变化步骤，会遍历两个文本中的每个字符两两比较，能够推断出时间复杂度至少为document1.length × document2.length，我所比较的章节字数平均在几千～一万字；这样计算实在要了老命。算法

想到Lucene中的评分机制，也是算一个类似度的问题，不过它采用的是计算向量间的夹角（余弦公式），在google黑板报中的：数学之美（余弦定理和新闻分类）也有说明，能够经过余弦定理来判断类似度；因而决定本身动手试试。测试

首相选择向量的模型：在以字为向量仍是以词为向量的问题上，纠结了一会；后来仍是以为用字，虽然词更为准确，但分词却须要增长额外的复杂度，而且此项目要求速度，准确率能够放低，因而仍是选择字为向量。优化

而后每一个字在章节中出现的次数，即是以此字向量的值。如今咱们假设： google

章节1中出现的字为：Z1c1,Z1c2,Z1c3,Z1c4……Z1cn；它们在章节中的个数为：Z1n1,Z1n2,Z1n3……Z1nm；编码

章节2中出现的字为：Z2c1,Z2c2,Z2c3,Z2c4……Z2cn；它们在章节中的个数为：Z2n1,Z2n2,Z2n3……Z2nm； spa

其中，Z1c1和Z2c1表示两个文本中同一个字，Z1n1和Z2n1是它们分别对应的个数， .net

最后咱们的类似度能够这么计算： code

程序实现以下：（如有可优化或更好的实现请不吝赐教）

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;


public class CosineSimilarAlgorithm {
	public static double getSimilarity(String doc1, String doc2) {
		if (doc1 != null && doc1.trim().length() > 0 && doc2 != null
				&& doc2.trim().length() > 0) {
			
			Map<Integer, int[]> AlgorithmMap = new HashMap<Integer, int[]>();
			
			//将两个字符串中的中文字符以及出现的总数封装到，AlgorithmMap中
			for (int i = 0; i < doc1.length(); i++) {
				char d1 = doc1.charAt(i);
				if(isHanZi(d1)){
					int charIndex = getGB2312Id(d1);
					if(charIndex != -1){
						int[] fq = AlgorithmMap.get(charIndex);
						if(fq != null && fq.length == 2){
							fq[0]++;
						}else {
							fq = new int[2];
							fq[0] = 1;
							fq[1] = 0;
							AlgorithmMap.put(charIndex, fq);
						}
					}
				}
			}

			for (int i = 0; i < doc2.length(); i++) {
				char d2 = doc2.charAt(i);
				if(isHanZi(d2)){
					int charIndex = getGB2312Id(d2);
					if(charIndex != -1){
						int[] fq = AlgorithmMap.get(charIndex);
						if(fq != null && fq.length == 2){
							fq[1]++;
						}else {
							fq = new int[2];
							fq[0] = 0;
							fq[1] = 1;
							AlgorithmMap.put(charIndex, fq);
						}
					}
				}
			}
			
			Iterator<Integer> iterator = AlgorithmMap.keySet().iterator();
			double sqdoc1 = 0;
			double sqdoc2 = 0;
			double denominator = 0; 
			while(iterator.hasNext()){
				int[] c = AlgorithmMap.get(iterator.next());
				denominator += c[0]*c[1];
				sqdoc1 += c[0]*c[0];
				sqdoc2 += c[1]*c[1];
			}
			
			return denominator / Math.sqrt(sqdoc1*sqdoc2);
		} else {
			throw new NullPointerException(
					" the Document is null or have not cahrs!!");
		}
	}

	public static boolean isHanZi(char ch) {
		// 判断是否汉字
		return (ch >= 0x4E00 && ch <= 0x9FA5);

	}

	/**
	 * 根据输入的Unicode字符，获取它的GB2312编码或者ascii编码，
	 * 
	 * @param ch
	 *            输入的GB2312中文字符或者ASCII字符(128个)
	 * @return ch在GB2312中的位置，-1表示该字符不认识
	 */
	public static short getGB2312Id(char ch) {
		try {
			byte[] buffer = Character.toString(ch).getBytes("GB2312");
			if (buffer.length != 2) {
				// 正常状况下buffer应该是两个字节，不然说明ch不属于GB2312编码，故返回'?'，此时说明不认识该字符
				return -1;
			}
			int b0 = (int) (buffer[0] & 0x0FF) - 161; // 编码从A1开始，所以减去0xA1=161
			int b1 = (int) (buffer[1] & 0x0FF) - 161; // 第一个字符和最后一个字符没有汉字，所以每一个区只收16*6-2=94个汉字
			return (short) (b0 * 94 + b1);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return -1;
	}
	
	public static void main(String[] args) {
		System.out.println(getSimilarity("我喜欢看电视，不喜欢看电影。", "我不喜欢看电视，也不喜欢看电影。"));
	}
}

程序中作了两小的改进，以加快效率：

1. 只将汉字做为向量，其余的如标点，数字等符号不处理；

2. 在HashMap中存放汉字和其在文本中对于的个数时，先将单个汉字经过GB2312编码转换成数字，再存放。

最后写了个测试，根据两种不一样的算法对比下时间，下面是测试结果：

余弦定理算法：doc1 与 doc2 类似度为：0.9954971, 耗时：22mm

距离编辑算法：doc1 与 doc2 类似度为：0.99425095, 耗时：322mm

可见效率有明显提升，算法复杂度大体为：document1.length + document2.length。