在 Python 中对单个数组进行更快的双重迭代

Question

我想找到一种方法来更快地计算成对精度，即比较同一数组的元素（在本例中是 panda df 列）计算它们的差异，然后比较获得的两个结果。我将有一个数据框 df 与 3 列（id 的文档，Jugment 代表人类评估，它是一个 int 对象，PR_score 代表该文档的 pagerank 并且它是一个浮动对象），我想检查他们是否同意将一个文档更好/最差地分类另一个文档。

例如：

id：id1、id2、id3

判断 : 1, 0, 0

PR_score：0.18、0.5、0.12

在这种情况下，两个分数一致认为 id1 比 id3 更好，在 id1 和 id2 上不一致，并且 id2 和 id3 之间存在人为判断关系，因此我的成对准确度是：

协议 = 1

不同意 = 1

成对准确度 = 一致/（一致+不一致）=1/2 = 0.5

这是我的第一个解决方案的代码，其中我使用 df 的列作为数组（这有助于减少计算时间）：

def pairwise(agree, disagree):
    return(agree/(agree+disagree))

def pairwise_computing_array(df):

    humanScores = np.array(df['Judgement'])  
    pagerankScores =  np.array(df['PR_Score']) 

    total = 0 
    agree = 0
    disagree = 0

    for i in range(len(df)-1):  
        for j in range(i+1, len(df)):
            total += 1
            human = humanScores[i] -  humanScores[j] #difference human judg
            if human != 0:
                pr = pagerankScores[i] -  pagerankScores[j]#difference pagerank score
                if pr != 0:
                    if np.sign(human) == np.sign(pr):  
                        agree += 1 #they agree in which of the two is better
                    else:
                        disagree +=1 #they do not agree in which of the two is better
                else:
                    continue;   
            else:
                continue;

    pairwise_accuracy = pairwise(agree, disagree)

    return(agree, disagree, total,  pairwise_accuracy)

我尝试使用列表推导以获得更快的计算，但它实际上比第一个解决方案慢：

def pairwise_computing_list_comprehension(df):

    humanScores = np.array(df['Judgement'])  
    pagerankScores =  np.array(judgmentPR['PR_Score']) 

    sign = [np.sign(pagerankScores[i] - pagerankScores[j]) == np.sign(humanScores[i] - humanScores[j] ) 
            for i in range(len(df)) for j in range(i+1, len(df)) 
                if (np.sign(pagerankScores[i] - pagerankScores[j]) != 0 
                    and np.sign(humanScores[i] - humanScores[j])!=0)]

    agreement = sum(sign)
    disagreement = len(sign) -  agreement                             
    pairwise_accuracy = pairwise(agreement, disagreement)

    return(agreement, disagreement, pairwise_accuracy)

我无法在整个数据集上运行，因为它需要太多时间，我希望能在理想情况下在 1 分钟内完成计算。

在我的计算机上计算 1000 行的一小部分达到了这个性能：

代码1： 每个循环 1.57 秒 ± 3.15 毫秒（平均值 ± 标准偏差。7 次运行，每个循环 1 个）

代码2： 每个循环 3.51 秒 ± 10.7 毫秒（平均值 ± 标准偏差，7 次运行，每个循环 1 个）

Answer 1

你有 numpy 数组，那么为什么不直接使用它呢？您可以将工作从 Python 转移到 C 编译代码（通常但不总是）：

首先，将向量调整为 1xN 矩阵：

humanScores = np.array(df['Judgement']).resize((1,-1))
pagerankScores =  np.array(judgmentPR['PR_Score']).resize((1,-1))

然后找出区别，我们只对标志感兴趣：

humanDiff = (humanScores - humanScores.T).clip(-1,1)
pagerankDiff = (pagerankScores - pagerankScores.T).clip(-1,1)

这里我假设数据是整数，所以clip函数只会产生-1、0或1。然后你就可以数了：

agree = ((humanDiff != 0) & (pagerankDiff != 0) & (humanDiff == pagerankDiff)).sum()
disagree = ((humanDiff != 0) & (pagerankDiff != 0) & (humanDiff != pagerankDiff)).sum()

但上述计数是双重计数，因为项目 (i,j) 和项目 (j,i) 在 humanDiff 和 pagerankDiff 中都是完全相反的符号。您可以考虑在求和中只取方阵的上三角部分：

agree = ((humanDiff != 0) &
         (pagerankDiff != 0) &
         (np.triu(humanDiff) == np.triu(pagerankDiff))
        ).sum()

Answer 2

这是在合理时间内工作的代码，感谢@juanpa.arrivillaga 的建议：

from numba import jit

@jit(nopython = True)
def pairwise_computing(humanScores, pagerankScores):

    total = 0 
    agree = 0
    disagree = 0

    for i in range(len(humanScores)-1):  
        for j in range(i+1, len(humanScores)):
            total += 1
            human = humanScores[i] -  humanScores[j] #difference human judg
            if human != 0:
                pr = pagerankScores[i] -  pagerankScores[j]#difference pagerank score
                if pr != 0:
                    if np.sign(human) == np.sign(pr):  
                        agree += 1 #they agree in which of the two is better
                    else:
                        disagree +=1 #they do not agree in which of the two is better
                else:
                    continue   
            else:
                continue
    pairwise_accuracy = agree/(agree+disagree)
    return(agree, disagree, total,  pairwise_accuracy)

这是我的整个数据集（58k 行）达到的时间性能：

每个循环 7.98 秒 ± 2.78 毫秒（平均值 ± 标准偏差，7 次运行，每个循环 1 个）

Answer 3

可以通过利用广播摆脱内部for 循环，因为索引j 总是比索引i 领先1（即我们不会回头）。但是在以下行中计算同意/不同意存在一个小问题：

if np.sign(human) == np.sign(pr):

我不知道如何解决。因此，我只是在此处提供骨架代码以进行更多调整并使其正常工作，因为您更了解问题所在。就是这样：

def pairwise_computing_array(df):

    humanScores = df['Judgement'].values
    pagerankScores = df['PR_Score'].values 

    total = 0 
    agree = 0
    disagree = 0

    for i in range(len(df)-1):
        j = i+1
        human = humanScores[i] -  humanScores[j:]   #difference human judg
        human_mask = human != 0
        if np.sum(human_mask) > 0:  # check for at least one positive case
            pr = pagerankScores[i] -  pagerankScores[j:][human_mask]  #difference pagerank score
            pr_mask = pr !=0
            if np.sum(pr_mask) > 0:  # check for at least one positive case
                # TODO: issue arises here; how to resolve when (human.shape != pr.shape) ?
                # once this `if ... else` block is fixed, it's done
                if np.sign(human) == np.sign(pr):
                    agree += 1   #they agree in which of the two is better
                else:
                    disagree +=1   #they do not agree in which of the two is better
            else:
                continue
        else:
            continue
    pairwise_accuracy = pairwise(agree, disagree)

    return(agree, disagree, total,  pairwise_accuracy)