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();

您可以扔掉为此编写的所有复杂代码。在使用并发或并行处理时，通常需要花一点时间考虑一下最佳设计。通常，对于常见问题有高度紧凑的解决方案。

使用Levenshtein距离（将每个元素彼此比较）从两个大型数据集中优化匹配元素

1 个答案: