如何调整 Levenshtein 距离算法以将匹配限制为单个单词？

Posted 2023-02-19

【中文标题】如何调整 Levenshtein 距离算法以将匹配限制为单个单词？

【英文标题】：How can I adapt the Levenshtein Distance algorithm to limit matches to a single word?

【发布时间】：2013-03-03 05:54:38

【问题描述】：

我在 C++ 中使用 Levenshtein 距离算法来比较两个字符串，以测量它们彼此之间的接近程度。但是，普通的 Levenshtein 距离算法不区分由空格分隔的单词边界。这导致距离计算比我想要的要小。我正在比较标题以查看它们彼此之间的接近程度，并且我希望算法不会将来自多个单词的字符视为匹配。

例如，如果我比较这两个字符串，我会得到以下结果，+ 表示匹配，- 表示不匹配：

Al Chertoff Et
Al Church Department of finance Et
+++++------+--++-----++-+------+++
Al Ch      e  rt     of f       Et

我得到了 20 与单词 "Chertoff" 匹配四个单词 "Church Department of finance" 的距离，而我真的希望通过不允许字符匹配多个单词来将它们彼此分开考虑与单词"Chertoff" 最匹配的单词"Department" 的距离为25，匹配三个字符：

Al Chertoff Et
Al Church Department of finance Et
+++--------+--++---------------+++
Al         e  rt                Et
         Ch     off

我如何调整 Levenshtein 距离来完成此任务，或者是否有另一种更适合此的距离算法？也许在每个单词上单独使用 Levenshtein 距离并选择距离最小的单词？但是，如果在字符串深处匹配一个单词会导致后续单词匹配不佳，因为它们的匹配最好在字符串的较早位置？这可以通过将 Levenshtein 距离调整为单词级别来以某种方式完成吗？

例如，对于下面更复杂的例子，这个想法的最短距离是20：

Al Chertoff Deport Et
Al Church Department of finance Et
+++++----++++-++---------------+++
Al Ch     Dep rt                Et
     ertoff  o

而不是最大化"Chertoff"的匹配并获得更长的距离24：

Al Chertoff Deport Et
Al Church Department of finance Et
+++--------+--++-----+---------+++
Al         e  rt     o          Et
         Ch     off
                  Dep rt

我目前对 Levenshtein Distance 的实现如下：

size_t
levenshtein_distance(const std::string& a_compare1,
                     const std::string& a_compare2) 
  const size_t length1 = a_compare1.size();
  const size_t length2 = a_compare2.size();
  std::vector<size_t> curr_col(length2 + 1);
  std::vector<size_t> prev_col(length2 + 1);

  // Prime the previous column for use in the following loop:
  for (size_t idx2 = 0; idx2 < length2 + 1; ++idx2) 
    prev_col[idx2] = idx2;
  

  for (size_t idx1 = 0; idx1 < length1; ++idx1) 
    curr_col[0] = idx1 + 1;

    for (size_t idx2 = 0; idx2 < length2; ++idx2) 
      const size_t compare = a_compare1[idx1] == a_compare2[idx2] ? 0 : 1;

      curr_col[idx2 + 1] = std::min(std::min(curr_col[idx2] + 1,
                                             prev_col[idx2 + 1] + 1),
                                    prev_col[idx2] + compare);
    

    curr_col.swap(prev_col);
  

  return prev_col[length2];

【问题讨论】：

“但是，如果在字符串深处匹配一个单词会导致后续单词匹配不佳，因为它们的匹配最好在字符串的较早位置” 你能用一个例子解释一下这个说法吗？举一个你喜欢的匹配例子。

如第二个例子"Al Church Department of finance Et"所示。

我有点晚了，你不能只是按单词分割和单独匹配单词吗？您实际上有两个编辑距离计算：一个在单词级别上，一个（在第一个内部）在两个单词内的字母级别上（仅当单词不匹配时）。 /EDIT 这听起来与斯蒂芬的回答很相似。

@KonradRudolph 是的，基本上就是这样，您只需要正确建模句子中单词的插入、删除和替换成本（因为单词中的字母它们总是 1，并且算法通常是写的有了这个假设）

【参考方案1】：

如果单个单词的长度不同，则会跨越单词边界。如果您想保持在各个单词中比较的索引，那么您需要使单词的长度相同。例如，这是一个 javascript（是的，我知道你问的是 C++，但这是为了说明 - 代码取自***）距离计算例程：

var memo = ;

function d(str1, i, len1, str2, j, len2)
    var key = [i,len1,j,len2].join(',');
    if(memo[key] != undefined) return memo[key];

    if(len1 == 0) return len2;
    if(len2 == 0) return len1;
    var cost = 0;
    if(str1[i] != str2[j]) cost = 1;

    var dist = Math.min(
        d(str1, i+1,len1-1, str2,j,len2)+1, 
        d(str1,i,len1,str2,j+1,len2-1)+1,
        d(str1,i+1,len1-1,str2,j+1,len2-1)+cost);
    memo[key] = dist;
    return dist;


var str1 = "Al Chertoff Deport$$$$ $$ $$$$$$$ Et";
var str2 = "Al Church$$ Department of finance Et";

console.log(d(str1, 0, str1.length, str2, 0, str2.length));

请注意我是如何修改两个输入字符串以在单个单词级别匹配的。运行这个我得到了 19 的距离。同样，如果我将字符串更改为：

var str1 = "Al Chertoff $$$$$$$$$$ $$ $$$$$$$ Et";
var str2 = "Al Church$$ Department of finance Et";

我的距离是 24。

【讨论】：

但是如何选择将$(s) 放在最后的Et 之前还是之后？ （例如"Al Chertoff Et$$$$$$$$ $$ $$$$$$$ $$"）

@Satyajit，这基本上需要在运行算法之前知道答案

我并不是说这就是 OP 应该做的，我只是在指出防止跨越单词边界的匹配需要单词具有相同的长度。您也可以争辩说，对于相同长度的字符串，我们将其减少为汉明距离计算，而不是编辑距离。

@Satyajit 它没有回答这个问题，甚至没有降低它的复杂性；还有更简单的方法可以防止跨单词边界匹配（只需用数字单词索引标记每个单词，不要让单词索引不匹配的字母比较相等）但是如果你看看他的问题，很明显他希望这个来处理单词以任意顺序添加或减去；您的解决方案在技术上允许这样做，但前提是您提前知道应该以哪些单词开头匹配，这不是比原始问题更简单的问题

@Satyajit（如果您提前知道应该排列哪些单词，标记算法也可以做同样的事情）

【参考方案2】：

通过将levenshtein_distance 设为序列容器上的通用算法并包含计算两个元素之间距离的成本函数，我可以非常接近您想要的结果：

template<typename T, typename C>
size_t
seq_distance(const T& seq1, const T& seq2, const C& cost,
             const typename T::value_type& empty = typename T::value_type()) 
  const size_t size1 = seq1.size();
  const size_t size2 = seq2.size();

  std::vector<size_t> curr_col(size2 + 1);
  std::vector<size_t> prev_col(size2 + 1);

  // Prime the previous column for use in the following loop:
  prev_col[0] = 0;
  for (size_t idx2 = 0; idx2 < size2; ++idx2) 
    prev_col[idx2 + 1] = prev_col[idx2] + cost(empty, seq2[idx2]);
  

  for (size_t idx1 = 0; idx1 < size1; ++idx1) 
    curr_col[0] = curr_col[0] + cost(seq1[idx1], empty);

    for (size_t idx2 = 0; idx2 < size2; ++idx2) 
      curr_col[idx2 + 1] = std::min(std::min(
        curr_col[idx2] + cost(empty, seq2[idx2]),
        prev_col[idx2 + 1] + cost(seq1[idx1], empty)),
        prev_col[idx2] + cost(seq1[idx1], seq2[idx2]));
    

    curr_col.swap(prev_col);
    curr_col[0] = prev_col[0];
  

  return prev_col[size2];

鉴于上述seq_distance，两个句子之间的编辑距离使得无法在单词边界之间进行编辑，可以如下定义：

size_t
letter_distance(char letter1, char letter2) 
  return letter1 != letter2 ? 1 : 0;


size_t
word_distance(const std::string& word1, const std::string& word2) 
  return seq_distance(word1, word2, &letter_distance);


size_t
sentence_distance(const std::string& sentence1, const std::string& sentence2) 
  std::vector<std::string> words1;
  std::vector<std::string> words2;
  std::istringstream iss1(sentence1);
  std::istringstream iss2(sentence2);
  std::copy(std::istream_iterator<std::string>(iss1),
            std::istream_iterator<std::string>(),
            std::back_inserter(words1));
  std::copy(std::istream_iterator<std::string>(iss2),
            std::istream_iterator<std::string>(),
            std::back_inserter(words2));
  return seq_distance(words1, words2, &word_distance);

这是在ideone 上工作的代码。我已经测试了几个案例，我很确定它做了正确的事情，但您应该多尝试一下，以确保结果合理。

请注意，这并不完全符合您的要求，因为它忽略了编辑距离测量中的所有空格：我认为修改它不这样做应该不会太难，但我没想到彻底通过。无论如何，这可能一样好（甚至更好），这取决于您的需要，所以我会让您决定是否要尝试调整它。

请注意，您的原始代码在以下两行中略有错误：

curr_col.reserve(length2 + 1);
prev_col.reserve(length2 + 1);

在向量中保留容量，但实际上并不更改它们的大小，因此在此之后访问数组是未定义的行为。如果您要访问某个范围内的元素，您实际上应该resize 向量：reserve 通常用于您即将push_back 一定数量的元素一个接一个的情况（这会增加大小随心所欲，而不是一次全部），并且您希望避免多次内部重新分配的成本（因为每次超出容量时，内部容量只会增加一定的系数）。

编辑：

This version 将单词之间的空格作为编辑距离的一部分考虑在内，但由于在某些情况下需要添加多个空格，因此结果仍与您的示例不完全相同。

【讨论】：

感谢您发现错误！

这正是我自己尝试的方法，但我正在思考用什么替换 curr_col[idx2] 和 curr_col[idx2 + 1] 的 +1。您是如何得出seq2[idx2] 和seq1[idx1] 是要使用的正确对应值的结论？

它是cost(empty, seq2[idx2])，在一种情况下是空元素和seq2[idx2] 之间的距离，在另一种情况下是cost(seq1[idx1], empty))，是空元素和seq1[idx1] 之间的距离（基本上是字符串长度在单词的情况下）...因为这些术语代表整个元素（即单词）的插入和删除。我不得不尝试找出哪个是哪个，实际上，但只有两个选择。

（cost(seq1[idx1], seq2[idx2])) 用于将一个词替换为另一个词...仍然不清楚方向，但无论如何它是对称的）

就我的使用而言，排除空格是有益的。