文本相似度算法(余弦定理)

最近由于工作项目，需要判断两个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是它们分别对应的个数，

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

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

[csharp]  view plain copy

1. public static double getSimilarity(String doc1, String doc2)  
2.        {  
3.            if (doc1 != null && doc1.Trim().Length > 0 && doc2 != null  
4.                    && doc2.Trim().Length > 0)  
5.            {  
6.                Dictionary<int, int[]> AlgorithmMap = new Dictionary<int, int[]>();  
7.                //将两个字符串中的中文字符以及出现的总数封装到，AlgorithmMap中  
8.                for (int i = 0; i < doc1.Length; i++)  
9.                {  
10.                    char d1 = doc1.ToCharArray()[i];  
11.                    if (isHanZi(d1))  
12.                    {  
13.                        int charIndex = getGB2312Id(d1);  
14.                        if (charIndex != -1)  
15.                        {  
16.                            int[] fq=null;  
17.                            try  
18.                            {  
19.                                 fq= AlgorithmMap[charIndex];  
20.                            }  
21.                            catch (Exception)  
22.                            {  
23.                            }  
24.                            finally {  
25.                                if (fq != null && fq.Length == 2)  
26.                                {  
27.                                    fq[0]++;  
28.                                }  
29.                                else  
30.                                {  
31.                                    fq = new int[2];  
32.                                    fq[0] = 1;  
33.                                    fq[1] = 0;  
34.                                    AlgorithmMap.Add(charIndex, fq);  
35.                                }  
36.                            }  
37.                        }  
38.                    }  
39.                }  
40.   
41.                for (int i = 0; i < doc2.Length; i++)  
42.                {  
43.                    char d2 = doc2.ToCharArray()[i];  
44.                    if (isHanZi(d2))  
45.                    {  
46.                        int charIndex = getGB2312Id(d2);  
47.                        if (charIndex != -1)  
48.                        {  
49.                            int[] fq=null;  
50.                            try  
51.                            {  
52.                                fq = AlgorithmMap[charIndex];  
53.                            }  
54.                            catch (Exception)  
55.                            {  
56.                            }  
57.                            finally {  
58.                                if (fq != null && fq.Length == 2)  
59.                                {  
60.                                    fq[1]++;  
61.                                }  
62.                                else  
63.                                {  
64.                                    fq = new int[2];  
65.                                    fq[0] = 0;  
66.                                    fq[1] = 1;  
67.                                    AlgorithmMap.Add(charIndex, fq);  
68.                                }  
69.                            }  
70.                        }  
71.                    }  
72.                }  
73.   
74.                double sqdoc1 = 0;  
75.                double sqdoc2 = 0;  
76.                double denominator = 0;  
77.                foreach (KeyValuePair<int, int[]> par in AlgorithmMap)  
78.                {  
79.                    int[] c = par.Value;  
80.                    denominator += c[0] * c[1];  
81.                    sqdoc1 += c[0] * c[0];  
82.                    sqdoc2 += c[1] * c[1];  
83.                }  
84.                return denominator / Math.Sqrt(sqdoc1 * sqdoc2);  
85.            }  
86.            else  
87.            {  
88.                throw new Exception();  
89.            }  
90.        }  
91.   
92.        public static bool isHanZi(char ch)  
93.        {  
94.            // 判断是否汉字  
95.            return (ch >= 0x4E00 && ch <= 0x9FA5);  
96.        }  
97.   
98.        /** 
99.         * 根据输入的Unicode字符，获取它的GB2312编码或者ascii编码， 
100.         *  
101.         * @param ch 
102.         *            输入的GB2312中文字符或者ASCII字符(128个) 
103.         * @return ch在GB2312中的位置，-1表示该字符不认识 
104.         */  
105.        public static short getGB2312Id(char ch)  
106.        {  
107.            try  
108.            {  
109.                byte[] buffer = System.Text.Encoding.GetEncoding("gb2312").GetBytes(ch.ToString());   
110.                if (buffer.Length != 2)  
111.                {  
112.                    // 正常情况下buffer应该是两个字节，否则说明ch不属于GB2312编码，故返回'?'，此时说明不认识该字符  
113.                    return -1;  
114.                }  
115.                int b0 = (int)(buffer[0] & 0x0FF) - 161; // 编码从A1开始，因此减去0xA1=161  
116.                int b1 = (int)(buffer[1] & 0x0FF) - 161; // 第一个字符和最后一个字符没有汉字，因此每个区只收16*6-2=94个汉字  
117.                return (short)(b0 * 94 + b1);  
118.            }  
119.            catch (Exception e)  
120.            {  
121.                Console.WriteLine(e.Message);  
122.            }  
123.            return -1;  
124.        }  
125.      

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

       1. 只将汉字作为向量，其他的如标点，数字等符号不处理；2. 在HashMap中存放汉字和其在文本中对于的个数时，先将单个汉字通过GB2312编码转换成数字，再存放。

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

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

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

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