使用编辑距离计算文本相似度

1. 使用simhash计算文本相似度
2. 使用余弦相似度计算文本相似度
3. 使用编辑距离计算文本相似度
4. jaccard系数计算文本相似度

---

3. 最小编辑距离计算文本相似度

3.1 编辑距离

概念：

通俗来讲，编辑距离Edit Distance（ED），是指将一个字符串转化为另一个字符串所需的最少操作数。操作包含以下几种：

• 增：增加一个字符
• 删：删除一个字符
• 改：修改一个字符

举例：

将“abc”转化为“acb”。

通过2次替换操作（即修改）将abc转化为了acb（使用删除再增加操作也可以），所以其最小编辑距离为2。

理论求解：

本质是一个递归问题，即对于两个长度为$L_1$和$L_2$的文本，要计算整个文本的最小编辑距离，就要算出$L_1-1$与$L_2$的编辑距离，然后再加1（针对增加操作的情况，添加最后一个字符），或者算出$L_1$与$L_2-1$的编辑距离，然后再加1（针对删除操作的情况，删除最后一个字符），或者算出$L_1-1$与$L_2-1$的编辑距离，然后再加1（针对修改操作的情况，修改一个字符），然后取这三个的最小值作为上一步的最小编辑距离，以此类推到第一个字符。

简化下以上文字：

假设有两个字符串$A$,$B$，其长度分别为$L_A$和$L_B$，那么对于3种操作的编辑距离为：

• 增加操作：
  $$d_1=ED(A_{i-1},B_j)+1$$

• 删除操作：
  $$d_2=ED(A_i,B_{j-1})+1$$

• 修改操作：
  $$d_3=\{\begin{array}{rlr}& ED(A_i-1,B_j-1)& (A_i=B_j)\\ & ED(A_i-1,B_j-1)+1& (A_i\ne B_j)\end{array}$$
  取这3个中的最小的一个即为最小编辑距离。

所以可以得到一个状态转移方程：
$$E{D}_{A_i{B}_j}=\{\begin{array}{rlr}& max(L_A,L_B)& (L_A=0||L_B=0)\\ & min\{\begin{array}{rl}& ED(A_{i-1},B_j)+1\\ & ED(A_i,B_{j-1})+1\\ & \begin{array}{rlr}& ED(A_i-1,B_j-1)& (A_i=B_j)\\ & ED(A_i-1,B_j-1)+1& (A_i\ne B_j)\end{array}\end{array}& \end{array}$$

3.2 计算编辑距离（递归）

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "acb";
        System.out.println(dis(s1, s2, s1.length(), s2.length()));
        //2
    }

    static int d = 0;

    private static int dis(String s1, String s2, int i, int j) {
        if (i == 0 || j == 0) {
            return Math.max(i, j);
        }
        int op1 = dis(s1, s2, i - 1, j) + 1;
        int op2 = dis(s1, s2, i, j - 1) + 1;
        int op3 = dis(s1, s2, i - 1, j - 1);
        if (s1.charAt(i - 1) != s2.charAt(j - 1)) {
            op3 += 1;
        }
        return Math.min(Math.min(op1, op2), op3);
    }

3.3 计算编辑距离（动态规划）

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "acb";
        System.out.println(dis(s1, s2));
        //2
    }

    private static int dis(String s1, String s2) {
        int[][] temp = new int[s1.length()][s2.length()];
        for (int i = 0; i < s1.toCharArray().length; i++) {
            temp[i][0] = i;
        }
        for (int j = 0; j < s2.toCharArray().length; j++) {
            temp[0][j] = j;
        }
        for (int i = 1; i < s1.toCharArray().length; i++) {
            for (int j = 1; j < s2.toCharArray().length; j++) {
                if (s1.charAt(i) == s2.charAt(j)) {
                    temp[i][j] = temp[i - 1][j - 1];
                } else {
                    int op1 = temp[i - 1][j] + 1;
                    int op2 = temp[i - 1][j - 1] + 1;
                    int op3 = temp[i][j - 1] + 1;
                    temp[i][j] = Math.min(Math.min(op1, op2), op3);
                }
            }
        }
        System.out.println(Arrays.deepToString(temp));
        return temp[s1.length() - 1][s2.length() - 1];
    }

3.4 最小编辑距离计算相似度

计算公式：
$$similarity=1-\frac{E{D}_{AB}}{max(L_A,L_B)}$$

举例：

A：今天天气真好，适合去逛街，也适合晒太阳。;
B：今天天气不错，适合去玩，也适合去晒太阳。;

最小编辑距离：$$E{D}_{AB}=5$$

相似度：$$similarity=1-\frac{E{D}_{AB}}{max(L_A,L_B)}=1-\frac{5}{20}=0.75$$

3.5 总结

最小编辑距离很直接的从字面上反映了两个文本间的差异程度，即两个文本越相似，其编辑距离就越小。但是由这种普通的编辑距离来计算相似度还是有些缺陷，比如：

• 耗时长
  对于短文本来说，速度还是比较快的，但是对于长文本，其速度就不是很理想了。其次，基于动态规划计算时使用的矩阵也会增加不少空间复杂度。以下是对1000字符内，以10为增量，在没有优化的情况下得到的最小编辑距离计算相似度的耗时：
  
• 计算不准确
  由于只是从文本字面本身来计算的，没有更多的特征来进行进一步判断，所以其结果不是很准确。个人认为可改进的方法有：计算分词后的词语的编辑距离，而不是一个字符的；在计算过程中加入权重等参数进行距离调整；基于同义词词库进行距离调整等等。这个后面陆续再总结。

---

So many ways to calculate the distance, but how to calculate the missing distance?