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

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

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

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

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

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

       首相选择向量的模型：在以字为向量还是以词为向量的问题上，纠结了一会；后来还是觉得用字，虽然词更为准确，但分词却需要增加额外的复杂度，并且此项目要求速度，准确率可以放低，于是还是选择字为向量。

       然后每个字在章节中出现的次数，便是以此字向量的值。现在我们假设：

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

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

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

       最后我们的相似度可以这么计算：

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

001 import java.io.UnsupportedEncodingException;
002 import java.util.HashMap;
003 import java.util.Iterator;
004 import java.util.Map;
005
006
007 public class CosineSimilarAlgorithm {
008     public static double getSimilarity(String doc1, String doc2) {
009         if (doc1 != null && doc1.trim().length() > 0 && doc2 != null
010                 && doc2.trim().length() > 0) {
011
012             Map<Integer, int[]> AlgorithmMap = new HashMap<Integer, int[]>();
013
014             //将两个字符串中的中文字符以及出现的总数封装到，AlgorithmMap中
015             for (int i = 0; i < doc1.length(); i++) {
016                 char d1 = doc1.charAt(i);
017                 if(isHanZi(d1)){
018                     int charIndex = getGB2312Id(d1);
019                     if(charIndex != -1){
020                         int[] fq = AlgorithmMap.get(charIndex);
021                         if(fq != null && fq.length == 2){
022                             fq[0]++;
023                         }else {
024                             fq = new int[2];
025                             fq[0] = 1;
026                             fq[1] = 0;
027                             AlgorithmMap.put(charIndex, fq);
028                         }
029                     }
030                 }
031             }
032
033             for (int i = 0; i < doc2.length(); i++) {
034                 char d2 = doc2.charAt(i);
035                 if(isHanZi(d2)){
036                     int charIndex = getGB2312Id(d2);
037                     if(charIndex != -1){
038                         int[] fq = AlgorithmMap.get(charIndex);
039                         if(fq != null && fq.length == 2){
040                             fq[1]++;
041                         }else {
042                             fq = new int[2];
043                             fq[0] = 0;
044                             fq[1] = 1;
045                             AlgorithmMap.put(charIndex, fq);
046                         }
047                     }
048                 }
049             }
050
051             Iterator<Integer> iterator = AlgorithmMap.keySet().iterator();
052             double sqdoc1 = 0;
053             double sqdoc2 = 0;
054             double denominator = 0;
055             while(iterator.hasNext()){
056                 int[] c = AlgorithmMap.get(iterator.next());
057                 denominator += c[0]*c[1];
058                 sqdoc1 += c[0]*c[0];
059                 sqdoc2 += c[1]*c[1];
060             }
061
062             return denominator / Math.sqrt(sqdoc1*sqdoc2);
063         } else {
064             throw new NullPointerException(
065                     " the Document is null or have not cahrs!!");
066         }
067     }
068
069     public static boolean isHanZi(char ch) {
070         // 判断是否汉字
071         return (ch >= 0x4E00 && ch <= 0x9FA5);
072
073     }
074
075     /**
076      * 根据输入的Unicode字符，获取它的GB2312编码或者ascii编码，
077      *
078      * @param ch
079      *            输入的GB2312中文字符或者ASCII字符(128个)
080      * @return ch在GB2312中的位置，-1表示该字符不认识
081      */
082     public static short getGB2312Id(char ch) {
083         try {
084             byte[] buffer = Character.toString(ch).getBytes("GB2312");
085             if (buffer.length != 2) {
086                 // 正常情况下buffer应该是两个字节，否则说明ch不属于GB2312编码，故返回'?'，此时说明不认识该字符
087                 return -1;
088             }
089             int b0 = (int) (buffer[0] & 0x0FF) - 161; // 编码从A1开始，因此减去0xA1=161
090             int b1 = (int) (buffer[1] & 0x0FF) - 161; // 第一个字符和最后一个字符没有汉字，因此每个区只收16*6-2=94个汉字
091             return (short) (b0 * 94 + b1);
092         } catch (UnsupportedEncodingException e) {
093             e.printStackTrace();
094         }
095         return -1;
096     }
097
098     public static void main(String[] args) {
099         System.out.println(getSimilarity("我喜欢看电视，不喜欢看电影。", "我不喜欢看电视，也不喜欢看电影。"));
100     }
101 }