使用 Levenshtein 距离优化来自两个大型数据集的匹配元素（将每个元素与其他元素进行比较）

Question

我目前正在解决一个问题，即从另一个名为“ListB”的列表中找到最匹配的数据，即“ListA”。每当我发现“ListA”的元素与“ListB”中的任何元素匹配时，该元素的置信度和准确度为 70% 或更高，我将列表 B 中的匹配字符串和列表 A 中的字符串添加到我进一步的元组中保存在数据库中。

Levenshtien 算法给了我一个数字，我将它与我的阈值 70 进行比较，如果返回的值等于或大于 70% 的阈值，我将其附加到“ListA”的原始字符串元素中。

如果“ListA”和“ListB”中的记录在数千个值范围内，并且如果我将记录增加到一百万个，则我为此过程编写的代码可以正常工作，大约需要一个小时来计算每个值的距离列表 A 的元素。

我需要针对庞大的数据集优化流程。请告知我需要在哪里进行改进。

到目前为止，我的流程代码如下所示

  public static PerformFuzzyMatch()
  {
    // Fetch the ListA & List B from SQL tables
     var ListACount = await FuzzyMatchRepo.FetchListACount();
     var ListB = await FuzzyMatchRepo.FetchListBAsync();

    //Split the ListA data to smaller chunks and loop through those chunks 
     var splitGroupSize = 1000;
     var sourceDataBatchesCount = ListACount / splitGroupSize;

     // Loop through the smaller chunks of List A
     for (int b = 0; b < sourceDataBatchesCount; b++)
     {
       var currentBatchMatchedWords = new List<Tuple<string, string, double>>();
       int skipRowCount = b * splitGroupSize;
       int takeRowCount = splitGroupSize;

       // Get chunks of data from ListA according to the skipRowCount and takeRowCount
   var currentSourceDataBatch = FuzzyMatchRepository.FetchSourceDataBatch(skipRowCount, takeRowCount);

 //Loop through the ListB and parallely calculate the distance between chunks of List A and List B data
   for (int i = 0; i < ListB.Count; i++)
   {
     Parallel.For(
      0,
      currentSourceDataBatch.Count,
      new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 10 },
      cntr =>
      {
         try
         {
            //call the Levenshtien Algorithm to calculate the distance between each element of ListB and the smaller chunk of List A.
              int leven = LevenshteinDistance(currentSourceDataBatch[cntr], ListB[i]);
              int length = Math.Max(currentSourceDataBatch[cntr].Length, ListB[i].Length);
              double similarity = double similarity = 1.0 - (double)leven / length;
              if ((similarity * 100) >= 70)
              {
     currentBatchMatchedWords.Add(Tuple.Create(currentSourceDataBatch[cntr], ListB[i], similarity));
            }
          cntr++;
         }
        catch (Exception ex)
        {
         exceptions.Enqueue(ex);
        }
      });
     }
   }
  }

它调用的算法是计算距离

public static int LevenshteinDistance(this string input, string comparedTo, bool caseSensitive = false)
    {
        if (string.IsNullOrWhiteSpace(input) || string.IsNullOrWhiteSpace(comparedTo))
        {
            return -1;
        }

        if (!caseSensitive)
        {
            input = Common.Hashing.InvariantUpperCaseStringExtensions.ToUpperInvariant(input);
            comparedTo = Common.Hashing.InvariantUpperCaseStringExtensions.ToUpperInvariant(comparedTo);
        }

        int inputLen = input.Length;
        int comparedToLen = comparedTo.Length;

        int[,] matrix = new int[inputLen, comparedToLen];

        //initialize           
        for (var i = 0; i < inputLen; i++)
        {
            matrix[i, 0] = i;
        }
        for (var i = 0; i < comparedToLen; i++)
        {
            matrix[0, i] = i;
        }

        //analyze
        for (var i = 1; i < inputLen; i++)
        {
            ushort si = input[i - 1];
            for (var j = 1; j < comparedToLen; j++)
            {
                ushort tj = comparedTo[j - 1];
                int cost = (si == tj) ? 0 : 1;

                int above = matrix[i - 1, j];
                int left = matrix[i, j - 1];
                int diag = matrix[i - 1, j - 1];
                int cell = FindMinimumOptimized(above + 1, left + 1, diag + cost);

                //transposition
                if (i > 1 && j > 1)
                {
                    int trans = matrix[i - 2, j - 2] + 1;
                    if (input[i - 2] != comparedTo[j - 1])
                    {
                        trans++;
                    }
                    if (input[i - 1] != comparedTo[j - 2])
                    {
                        trans++;
                    }
                    if (cell > trans)
                    {
                        cell = trans;
                    }
                }
                matrix[i, j] = cell;
            }
        }
        return matrix[inputLen - 1, comparedToLen - 1];
    }

寻找最小值优化的实现

public static int FindMinimumOptimized(int a, int b, int c)
    {
        return Math.Min(a, Math.Min(b, c));
    }

Answer 1

这是一个固有地具有二次成本O(N^2) 的计算。随着项目数量的增加，这总是会非常糟糕地扩展。

您可以将其并行化，但这只是执行时间的常数因子增益。

你能找到其他一些基于平等的标准来匹配吗？在这种情况下，您可以使用基于哈希的算法来非常快速地创建候选检查。例如，假设您正在匹配文本文章，并且您希望几乎所有 Levenstein 匹配都出现在同一日历日撰写的文章中，那么您可以先按日期匹配（使用 O(N) 复杂度），然后才对所有文章进行二次比较那天的物品。您还可以比较前一天和第二天的项目，以留出一些余地。

如果你不能这样做，你必须接受二次缩放。

一个好的代码模式是这样的：

var pairs = (from a in listA
             from b in listB //cross product
             select new { a, b });

var matches = 
 pairs
 .AsParallel()
 .Where(pair => IsLevenshteinMatch(pair))
 .ToList();

您可以丢弃为此编写的所有复杂代码。在使用并发性或并行性时，考虑一下最好的设计通常是值得的。通常，对于常见问题有非常紧凑的解决方案。