Java实现余弦定理计算文本相似度

相似度度量（Similarity），即计算个体间的相似程度，相似度度量的值越小，说明个体间相似度越小，相似度的值越大说明个体差异越大。
对于多个不同的文本或者短文本对话消息要来计算他们之间的相似度如何，一个好的做法就是将这些文本中词语，映射到向量空间，形成文本中文字和向量数据的映射关系，通过计算几个或者多个不同的向量的差异的大小，来计算文本的相似度。下面介绍一个详细成熟的向量空间余弦相似度方法计算相似度
向量空间余弦相似度(Cosine Similarity)

余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫"余弦相似性"。

思路上就是：将文本中的词汇映射到向量空间，来计算两个向量的夹角余弦值，作为两个文本相似度的判断。

代码参考如下：

[java] view plain copy

 

1. package com.test;  
2.   
3. import java.io.UnsupportedEncodingException;  
4. import java.util.HashMap;  
5. import java.util.Iterator;  
6. import java.util.Map;  
7.   
8. public class Cosine {  
9.       
10.     public static double getSimilarity(String doc1, String doc2) {  
11.         if (doc1 != null && doc1.trim().length() > 0 && doc2 != null&& doc2.trim().length() > 0) {  
12.               
13.             Map<Integer, int[]> AlgorithmMap = new HashMap<Integer, int[]>();  
14.               
15.             //将两个字符串中的中文字符以及出现的总数封装到，AlgorithmMap中  
16.             for (int i = 0; i < doc1.length(); i++) {  
17.                 char d1 = doc1.charAt(i);  
18.                 if(isHanZi(d1)){//标点和数字不处理  
19.                     int charIndex = getGB2312Id(d1);//保存字符对应的GB2312编码  
20.                     if(charIndex != -1){  
21.                         int[] fq = AlgorithmMap.get(charIndex);  
22.                         if(fq != null && fq.length == 2){  
23.                             fq[0]++;//已有该字符，加1  
24.                         }else {  
25.                             fq = new int[2];  
26.                             fq[0] = 1;  
27.                             fq[1] = 0;  
28.                             AlgorithmMap.put(charIndex, fq);//新增字符入map  
29.                         }  
30.                     }  
31.                 }  
32.             }  
33.   
34.             for (int i = 0; i < doc2.length(); i++) {  
35.                 char d2 = doc2.charAt(i);  
36.                 if(isHanZi(d2)){  
37.                     int charIndex = getGB2312Id(d2);  
38.                     if(charIndex != -1){  
39.                         int[] fq = AlgorithmMap.get(charIndex);  
40.                         if(fq != null && fq.length == 2){  
41.                             fq[1]++;  
42.                         }else {  
43.                             fq = new int[2];  
44.                             fq[0] = 0;  
45.                             fq[1] = 1;  
46.                             AlgorithmMap.put(charIndex, fq);  
47.                         }  
48.                     }  
49.                 }  
50.             }  
51.               
52.             Iterator<Integer> iterator = AlgorithmMap.keySet().iterator();  
53.             double sqdoc1 = 0;  
54.             double sqdoc2 = 0;  
55.             double denominator = 0;   
56.             while(iterator.hasNext()){  
57.                 int[] c = AlgorithmMap.get(iterator.next());  
58.                 denominator += c[0]*c[1];  
59.                 sqdoc1 += c[0]*c[0];  
60.                 sqdoc2 += c[1]*c[1];  
61.             }  
62.               
63.             return denominator / Math.sqrt(sqdoc1*sqdoc2);//余弦计算  
64.         } else {  
65.             throw new NullPointerException(" the Document is null or have not cahrs!!");  
66.         }  
67.     }  
68.   
69.     public static boolean isHanZi(char ch) {  
70.         // 判断是否汉字  
71.         return (ch >= 0x4E00 && ch <= 0x9FA5);  
72.         /*if (ch >= 0x4E00 && ch <= 0x9FA5) {//汉字 
73.             return true; 
74.         }else{ 
75.             String str = "" + ch; 
76.             boolean isNum = str.matches("[0-9]+");  
77.             return isNum; 
78.         }*/  
79.         /*if(Character.isLetterOrDigit(ch)){ 
80.             String str = "" + ch; 
81.             if (str.matches("[0-9a-zA-Z\\u4e00-\\u9fa5]+")){//非乱码 
82.                 return true; 
83.             }else return false; 
84.         }else return false;*/  
85.     }  
86.   
87.     /** 
88.      * 根据输入的Unicode字符，获取它的GB2312编码或者ascii编码， 
89.      *  
90.      * @param ch 输入的GB2312中文字符或者ASCII字符(128个) 
91.      * @return ch在GB2312中的位置，-1表示该字符不认识 
92.      */  
93.     public static short getGB2312Id(char ch) {  
94.         try {  
95.             byte[] buffer = Character.toString(ch).getBytes("GB2312");  
96.             if (buffer.length != 2) {  
97.                 // 正常情况下buffer应该是两个字节，否则说明ch不属于GB2312编码，故返回'?'，此时说明不认识该字符  
98.                 return -1;  
99.             }  
100.             int b0 = (int) (buffer[0] & 0x0FF) - 161; // 编码从A1开始，因此减去0xA1=161  
101.             int b1 = (int) (buffer[1] & 0x0FF) - 161;   
102.             return (short) (b0 * 94 + b1);// 第一个字符和最后一个字符没有汉字，因此每个区只收16*6-2=94个汉字  
103.         } catch (UnsupportedEncodingException e) {  
104.             e.printStackTrace();  
105.         }  
106.         return -1;  
107.     }  
108.       
109.     public static void main(String[] args) {  
110.         String str1="余弦定理算法：doc1 与 doc2 相似度为：0.9954971, 耗时：22mm";  
111.         String str2="余弦定理算法：doc1 和doc2 相似度为：0.99425095, 用时：33mm";  
112.         long start=System.currentTimeMillis();    
113.         double Similarity=Cosine.getSimilarity(str1, str2);  
114.         System.out.println("用时:"+(System.currentTimeMillis()-start));   
115.         System.out.println(Similarity);  
116.     }  
117. }  

原址:http://blog.csdn.net/fjssharpsword/article/details/53693115

执行结果：

[plain] view plain copy

 

1. 用时:16  

1. 0.8461538461538461