查找Damerau-Levenshtein编辑距离算法检测到的错误

问题描述

我正在创建一个拼写校正工具，并希望使用贝叶斯定理实现一个嘈杂的频道。为此，我需要计算概率P（X | W），其中X是给定（拼写错误）的单词，W是可能的校正。通过从混淆矩阵中获取一个值来给出概率，该值取决于知道发生了哪种类型的错误，这意味着，例如，如果X =“ egh”和W =“ egg”，则编辑距离将为1，并且错误将是字符2发生的替换错误。

我正在尝试找到一种方法来获取错误“类型”及其发生的字符，但似乎无法使其正常工作。 我尝试过创建TreeMap并在检测到错误时插入i / j值，但这没有用。

我可以假设只有一个错误，这意味着编辑距离恰好是1。

这是我的代码：

public static int DLD(String s1,String s2) {
    if (s1 == null || s2 == null) {  // Invalid input
        return -1;
    }

    if (s1.equals(s2)) {  // No distance to compute
        return 0;
    }

    // The max possible distance
    int inf = s1.length() + s2.length();

    // Create and initialize the character array indices
    HashMap<Character,Integer> da = new HashMap<>();
    for (int i = 0; i < s1.length(); ++i) {
        da.put(s1.charat(i),0);
    }
    for (int j = 0; j < s2.length(); ++j) {
        da.put(s2.charat(j),0);
    }

    // Create the distance matrix H[0 .. s1.length+1][0 .. s2.length+1]
    int[][] distances = new int[s1.length() + 2][s2.length() + 2];

    // initialize the left and top edges of H
    for (int i = 0; i <= s1.length(); ++i) {
        distances[i + 1][0] = inf;
        distances[i + 1][1] = i;
    }

    for (int j = 0; j <= s2.length(); ++j) {
        distances[0][j + 1] = inf;
        distances[1][j + 1] = j;

    }

    // fill in the distance matrix H
    // look at each character in s1
    for (int i = 1; i <= s1.length(); ++i) {
        int db = 0;

        // look at each character in s2
        for (int j = 1; j <= s2.length(); ++j) {
            int i1 = da.get(s2.charat(j - 1));
            int j1 = db;

            int cost = 1;
            if (s1.charat(i - 1) == s2.charat(j - 1)) {
                cost = 0;
                db = j;
            }

            distances[i + 1][j + 1] = min(
                    distances[i][j] + cost,// substitution
                    distances[i + 1][j] + 1,// insertion
                    distances[i][j + 1] + 1,// deletion
                    distances[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1));

        }

        da.put(s1.charat(i - 1),i);
    }

    return distances[s1.length() + 1][s2.length() + 1];
}

任何解决此问题的提示/方向将不胜感激。

谢谢！

编辑1： 尽管我不确定100％，但我想出了一些办法，它似乎可以正常工作。我用以下代码替换了使用min（）方法的代码段：

int sub = distances[i][j] + cost;
int ins = distances[i + 1][j] + 1;
int del = distances[i][j + 1] + 1;
int trans = distances[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1);

distances[i + 1][j + 1] = min(sub,ins,del,trans);

if ((distances[i][j] == 0 || distances[i - 1][j] == 0 || 
     distances[i][j - 1] == 0 || distances[i + 1][j + 1] == trans) &&
                    distances[i + 1][j + 1] == 1) {
                
    TreeMap<String,Integer> error = mappingTermAndError.getorDefault(s2,null);
    if (error != null) {
        error.clear();
    } else {
        error = new TreeMap<>();
    }

    if (distances[i + 1][j + 1] == trans) {
        error.put("trans",i - 2);

    } else if (distances[i + 1][j + 1] == del) {
        error.put("del",i - 1);

    } else if (distances[i + 1][j + 1] == ins) {
        error.put("ins",i - 1);

    } else {  // distances[i + 1][j + 1] == sub
        error.put("sub",i - 1);
    }
    mappingTermAndError.put(s2,error);
}

它的基本作用是获取每种错误类型的值，然后计算最小值。 如果新的最小值为1（因此这是第一个错误），并且距离矩阵中的先前单元格也为0（表示存在一条没有错误的路径导致该点），或者错误是转置的（我们可以仅在知道我们已经出了一个错误之后才知道），然后我用新的错误替换了先前注册的错误，并获得了与该错误所针对的字符相对应的'i'。

我知道此解决方案非常丑陋，而且效率可能不高，因此，如果有人对如何进行改进有任何想法，那就太好了。

解决方法

所涉及的错误类型和字符必须存储在某个地方。您可以将它们放在单独的数据结构中，也可以将它们封装在对象中。

这就是使用对象的样子。为简单起见，我仅实现Levenshtein距离，但是我相信您可以轻松地将该技术应用于Damerau–Levenshtein。

首先，您需要定义一个类，其中封装了有关编辑的信息：成本，父项以及任何其他信息，例如类型（替换，插入，删除）或涉及的字符。为了简单起见，我为这个额外的信息保留了一个名为“ type”的字符串，但是您可能想为错误的类型，字符索引等添加单独的字段。您甚至可能希望使用继承来创建不同的字段具有不同行为的编辑的子类型。

class Edit implements Comparable<Edit> {
    int cost;
    Edit parent;
    String type;

    public Edit() {
        // create a "start" node with no parent and zero cost
    }

    public Edit(String type,Edit parent,int cost) {
        this.type = type;
        this.cost = parent.cost + cost;
        this.parent = parent;
    }

    @Override
    public int compareTo(Edit o) {
        return Integer.compare(this.cost,o.cost);
    }

    @Override
    public String toString() {
        return type;
    }
}

然后，您可以使用此类而不是仅将int用于距离表。在0,0处有一个特殊的起始节点，没有父节点。在其他所有点上，您都需要根据到达该节点所需的最低成本来选择具有一个父节点或另一个父节点的节点。为了更加灵活，让我们从editDistance方法中拆分出矩阵的构建：

Edit[][] buildMatrix(String s1,String s2) {
    Edit[][] distance = new Edit[s1.length() + 1][s2.length() + 1];

    distance[0][0] = new Edit();
    for (int i = 1; i <= s1.length(); i++) {
        distance[i][0] = new Edit("-" + s1.charAt(i - 1),distance[i - 1][0],1);
    }
    for (int j = 1; j <= s2.length(); j++) {
        distance[0][j] = new Edit("+" + s2.charAt(j - 1),distance[0][j - 1],1);
    }

    for (int i = 1; i <= s1.length(); i++) {
        for (int j = 1; j <= s2.length(); j++) {
            int replaceCost = s1.charAt(i - 1) == s2.charAt(j - 1) ? 0 : 1;
            distance[i][j] = Collections.min(List.of(
                // replace or same
                new Edit(s1.charAt(i - 1) + "/" + s2.charAt(j - 1),distance[i - 1][j - 1],replaceCost),// delete
                new Edit("-" + s1.charAt(i - 1),distance[i - 1][j],1),// insert
                new Edit("+" + s2.charAt(j - 1),distance[i][j - 1],1)));
        }
    }

    return distance;
}

然后，“编辑距离”功能仅需承担最后一个节点的费用：

int editDistance(String s1,String s2) {
    Edit[][] distance = buildMatrix(s1,s2);
    return distance[s1.length()][s2.length()].cost;
}

但是由于有了“父”指针，您还可以轻松构建将一个字符串更改为另一个字符串（也称为“ diff”）所需的编辑列表：

List<Edit> diff(String s1,s2);
    List<Edit> diff = new ArrayList<>();
    Edit edit = distance[s1.length()][s2.length()];
    while (edit != distance[0][0]) {
        diff.add(edit);
        edit = edit.parent;
    }
    Collections.reverse(diff);
    return diff;
}