文本类似度计算基本方法小结

类似度计算方面

Jaccard类似度：集合之间的Jaccard类似度等于交集大小与并集大小的比例。适合的应用包括文档文本类似度以及顾客购物习惯的类似度计算等。

Shingling：k-shingle是指文档中连续出现的任意k个字符。若是将文档表示成其k-shingle集合，那么就能够基于集合之间的 Jaccard类似度来计算文档之间的文本类似度。有时，将shingle哈希成更短的位串很是有用，能够基于这些哈希值的集合来表示文档。

最小哈希：集合上的最小哈希函数基于全集上的排序转换来定义。给定任意一个排列转换，集合的最小哈希值为在排列转换次序下出现的第一个集合元素。

最小哈希签名：能够选出多个排列转换，而后在每一个排列转换下计算集合的最小哈希值，这些最小哈希值序列构成集合的最小哈希签名。给定两个集合，产生相同哈希值的排列转换所占的指望比率正好等于集合之间的Jaccard类似度。

高效最小哈希：因为实际不可能产生随机的排列转换，所以一般会经过下列方法模拟一个排列转换：选择一个随机哈希函数，利用该函数对集合中全部的元素进行哈希操做，其中获得的最小值当作是集合的最小哈希值。

签名的局部敏感哈希：该技术能够容许咱们避免计算全部集合对或其最小哈希签名对之间的类似度。给定集合的签名，咱们能够将它们划分红行条，而后仅仅计算至少有一个行条相等的集合对之间的类似度。经过合理选择行条大小，能够消除不知足类似度阈值的大部分集合对之间的比较。

 

向量空间距离方面

欧式距离：n维空间下的欧式距离，是两个点在各维上差值的平方和的算数平方根。适合欧式空间的另外一个距离是曼哈顿距离，指两个点各维度的差的绝对值之和。

Jaccard距离：1减去Jaccard类似度也是一个距离测度。

余弦距离：向量空间下两个向量的夹角大小。

编辑距离：该距离测度应用于字符串，指的是经过须要的插入、删除操做将一个字符串处理成另外一个字符串的操做次数。编辑距离还能够经过两个字符串长度之和减去二者最长公共子序列长度的两倍来计算。

海明距离：应用于向量空间。两个向量之间的海明距离计算的是它们之间不相同的位置个数。

 

索引辅助方面

字符索引：若是将集合表示成字符串，且须要达到的类似度阈值接近1。那么就能够将每一个字符串按照其头部的一小部分字母创建索引。须要索引的前缀的长度大概等于整个字符串的长度乘以给定的最大的Jaccard距离。

位置索引：咱们不只能够给出索引字符串前缀中的字符，也能够索引其在前缀中的位置。若是两个字符串共有的一个字符并不出如今双方的第一个位置，那么咱们就知道要么存在某些前面的字符出如今并集但不出如今交集中，那么在两个字符串中存在一个更前面的公共字符。这样的话，咱们就能够减小须要比较的字符串对数目。

后缀索引：咱们不只能够索引字符串前缀中的字符及其位置，还能够索引当前字符后缀的长度，即字符串中该字符以后的位置数量。因为相同字符可是后缀长度不一样意味着有额外的字符必须出如今并集但不出如今交集中，所以上述结构可以进一步减小须要比较的字符串数目。

 

总结

以上的一些概念和方法能够配合使用，能够基本知足许多场景下的类似度计算。类似度计算又能够为相关推荐作基础。怎么作好词的粒度切分，怎么划定阈值，选择何种距离测算，如何优化实现方法仍是要下不少功夫的。

 

两个例子

Levenshtein实际上是编辑距离，下面计算编辑距离的方法是把两个String串里的字/词当成一个矩阵来比较和计算。

public class LevenshteinDis {  
  
    public static void main(String[] args) {  
        // 要比较的两个字符串  
        String str1 = "类似度计算方法";  
        String str2 = "文本类似项发现";  
        levenshtein(str1, str2);  
    }  
  
    public static void levenshtein(String str1, String str2) {  
  
        int len1 = str1.length();  
        int len2 = str2.length();  
  
        int[][] dif = new int[len1 + 1][len2 + 1];  
  
        for (int a = 0; a <= len1; a++) {  
            dif[a][0] = a;  
        }  
        for (int a = 0; a <= len2; a++) {  
            dif[0][a] = a;  
        }  
          
        int temp;  
        for (int i = 1; i <= len1; i++) {  
            for (int j = 1; j <= len2; j++) {  
                if (str1.charAt(i - 1) == str2.charAt(j - 1)) {  
                    temp = 0;  
                } else {  
                    temp = 1;  
                }  
                // 取三个值中最小的  
                dif[i][j] = min(dif[i - 1][j - 1] + temp, dif[i][j - 1] + 1,  
                        dif[i - 1][j] + 1);  
            }  
        }  
        System.out.println("字符串\"" + str1 + "\"与\"" + str2 + "\"的比较");  
        System.out.println("差别步骤：" + dif[len1][len2]);  
        // 计算类似度  
        float similarity = 1 - (float) dif[len1][len2]  
                / Math.max(str1.length(), str2.length());  
        System.out.println("类似度：" + similarity);  
    }  
  
    private static int min(int... is) {  
        int min = Integer.MAX_VALUE;  
        for (int i : is) {  
            if (min > i) {  
                min = i;  
            }  
        }  
        return min;  
    }  
  
}

下面是余弦距离计算的例子：

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;  
    }  
}