排序列表差异

Question

我有以下问题。

我有一组元素，我可以按某种算法A排序。分拣很好，但非常昂贵。

还有一个算法B可以近似A的结果。它更快，但排序不会完全相同。

将A的输出作为“黄金标准”，我需要对在相同数据上使用B的错误进行有意义的估计。

任何人都可以建议我可以查看任何资源来解决我的问题吗？ 提前谢谢！

编辑：

根据要求：添加一个例子来说明案例： 如果数据是字母表的前10个字母，

A输出：a，b，c，d，e，f，g，h，i，j

B输出：a，b，d，c，e，g，h，f，j，i

产生错误的可能措施是什么，这样我就可以调整算法B的内部参数，使结果更接近A的输出？

Answer 1

我会确定最大的正确排序子集。

                               +-------------> I
                               |   +--------->
                               |   |
A -> B -> D ----->  E  -> G -> H --|--> J
     |             ^ |             |    ^
     |             | |             |    |
     +------> C ---+ +-----------> F ---+

在你的例子中，7个中有7个，所以算法得分为0.7。其他组的长度为6.正确的排序分数为1.0，反向排序为1 / n。

我认为这与反转次数有关。 x + y表示x <= y（正确顺序），x-y表示x> y。 y（错误的订单）。

A + B + D - C + E + G + H - F + J - I

我们获得了几乎相同的结果 - 9个中的6个是正确的sc 0.667。再次正确的排序分数1.0和反向排序0.0，这可能更容易计算。

Answer 2

斯皮尔曼的rho

我认为你想要的是Spearman's rank correlation coefficient。使用两个排序的索引[rank]向量（完美A和近似B），您可以计算从-1（完全不同）到1（完全不同）的等级相关rho相同）：

其中d（i）是A和B之间每个字符的等级差异

您可以将误差衡量标准定义为距离D := (1-rho)/2。

Answer 3

您是否正在寻找一些基于使用A排序的数组和以B作为输入排序的数组来计算差异的算法？或者您是否正在寻找一种通用的方法来确定使用B进行排序时阵列的平均值？

如果是第一个，那么我建议一些简单的事情，就像每个项目距离应该的距离一样（平均值会比一个总和更好地删除数组的长度作为一个问题）

如果是第二个，那么我想我需要了解更多有关这些算法的信息。

Answer 4

计算RMS Error可能是许多可能的方法之一。这是一个小的python代码。

def calc_error(out_A,out_B):
        # in    <= input
        # out_A <= output of algorithm A
        # out_B <= output of algorithm B

        rms_error = 0

        for i in range(len(out_A)):
            # Take square of differences and add
            rms_error +=  (out_A[i]-out_B[i])**2 

        return rms_error**0.5   # Take square root

>>> calc_error([1,2,3,4,5,6],[1,2,3,4,5,6])
0.0
>>> calc_error([1,2,3,4,5,6],[1,2,4,3,5,6]) # 4,3 swapped
1.414
>>> calc_error([1,2,3,4,5,6],[1,2,4,6,3,5]) # 3,4,5,6 randomized
2.44

注意：  取平方根不是必要的，但取正方形只是差异可能总和为零。我认为calc_error函数给出了错误放置的对的近似数量，但我没有任何编程工具，所以:(。

查看 this question.

Answer 5

很难给出一个好的通用答案，因为适合您的解决方案将取决于您的应用程序。

我最喜欢的选项之一就是有序元素对的数量除以对的总数。这是一个很好，简单，易于计算的指标，只能告诉您有多少错误。但它没有试图量化这些错误的严重程度。

double sortQuality = 1;
if (array.length > 1) {
   int inOrderPairCount = 0;
   for (int i = 1; i < array.length; i++) {
      if (array[i] >= array[i - 1]) ++inOrderPairCount;
   }
   sortQuality = (double) inOrderPairCount / (array.length - 1);
}

Answer 6

您可以尝试涉及hamming distance

的内容