Question

我有一个2-D浮点数组，并希望计算每列中阈值大于阈值的字段数，并将其存储在1-D数组中。当前我使用以下代码，但需要很长时间（数组大小：27000乘27000）。任何人都可以告诉我一个更快的方法。

以下是我的代码：

for Column in range(len(CorrelationData)):
BestMatchCount[0][Column] = sum(i >= Threshold for i in CorrelationData[:][Column])

Answer 1

你应该使用纯粹的NumPy，Python的for循环会降低它的速度：

>>> arr = np.random.rand(1000, 1000)                                   
>>> %timeit [sum(i >= 0.5 for i in arr.T[c]) for c in xrange(len(arr))]
1 loops, best of 3: 1.58 s per loop
>>> %timeit np.sum(arr >= 0.5, axis=0)
1000 loops, best of 3: 1.53 ms per loop

Answer 2

最好的，但可能不是提高性能的最简单方法是遵循分而治之的方法。创建一个子步骤来遍历每一列，并让线程执行所需的计算。然后，一旦所有线程完成并返回其值，编译值以找到结果。

编辑：添加了一些示例代码。变量2DArray表示OP问题中的2d阵列。

import threading

class Worker(threading.Thread):
    def __init__(self, threadID, name, column):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.column = column

        self.start()

    def run(self):
        # Do work here.

        threadLock.acquire()
        # Increment threshold counter here.
        counter += self.doWork(self.column)
        threadLock.release()

    def doWork(self, colum):
        count = 0
        for row in column:
            # Test if number is above threshold.

threadLock = threading.Lock()
threads = []
counter = 0

tid = 0
for column in 2DArray:
    threads.append(Worker(tid, 'thread-{0}'.format(tid), column))
    tid += 1

for thread in threads:
    thread.join()

Answer 3

不幸的是，除非你使用矢量化处理或其他一些并行方法作弊，否则列的总和非常严格为O（n ^ 2）。如果您的语言灵活，R的隐式向量化可能是一个简单的解决方案。如果没有那么我认为并行化与一些线程在完成后连续列可能是最快的方式（正如安德鲁在我之前建议的那样）。

Answer 4

首先使用以下命令对数组进行排序

a = [5, 2, 3, 1, 4]
a.sort()

然后你可以使用if命令。一旦达到阈值，就可以停止搜索。

这可能会加快你的搜索速度。在python中排序要快得多。

对于反向排序列表，您可以使用以下命令

def reverse_numeric(x, y):
      return y - x
sorted([5, 2, 4, 1, 3], cmp=reverse_numeric)
[5, 4, 3, 2, 1]

https://wiki.python.org/moin/HowTo/Sorting了解更多信息

Python：最快的遍历二维数组的方法

4 个答案: