每次迭代之后，Python代码都会变慢

Question

我有下面的代码，它应该对一个数据向量做一些运算并存储结果，我的问题是，当我开始运行这段代码时，每次迭代（每个outter循环）大约需要12秒，但经过一段时间后，迭代的时间在结束时变得更长，每次迭代需要2分钟才能完成，我想知道出了什么问题用我的密码？这与我保存的内存大小和数组大小有关吗？如果是，我怎么解决？如果没有，有什么问题？在

allclassifiers是2D向量：allclassifiers.shape = tuple: (1020, 1629)这意味着my for应该循环1629次，每次对大小为1020的向量执行操作，每个向量都是数组0或1s

最后，points_comb的大小约为400MB，points_comb.shape = tuple: (26538039, 2)，我必须指出我在一个有4GB RAM的系统上运行代码。
valid_list是0和1的向量，大小为1020，valid_list.shape tuple: (1020,)

startTime = datetime.now()

for i in range(allclassifiers.shape[1]):
    for j in range(allclassifiers.shape[1]):
        rs_t = combine_crisp(valid_list, allclassifiers[:,i], allclassifiers[:,j], boolean_function)
        fpr_tmp, tpr_tmp = resp2pts(valid_list, rs_t)
        points_comb = np.vstack((points_comb,np.hstack((fpr_tmp, tpr_tmp))))
    endTime = datetime.now()
    executionTime = endTime - startTime
    print "Combination for classifier: " + str(i)+ ' ' + str(executionTime.seconds / 60) + " minutes and " + str((executionTime.seconds) - ((executionTime.seconds / 60)*60)) +" seconds"


def combine_crisp(lab, r_1, r_2, fun):

    rs = np.empty([len(lab), len(fun)])
    k = 0
    for b in fun:
        if b == 1:            #----------------> 'A AND B'
            r12 = np.logical_and(r_1, r_2)
        elif b == 2:            #----------------> 'NOT A AND B'
            r12 = np.logical_not(np.logical_and(r_1, r_2))
        elif b == 3:            #----------------> 'A AND NOT B'
            r12 = np.logical_and(r_1, np.logical_not (r_2))
        elif b == 4:            #----------------> 'A NAND B'
            r12 = np.logical_not( (np.logical_and(r_1, r_2)))
        elif b == 5:            #----------------> 'A OR B'
            r12 = np.logical_or(r_1, r_2)
        elif b == 6:            #----------------> 'NOT A OR B'; 'A IMP B'
            r12 = np.logical_not (np.logical_or(r_1, r_2))
        elif b == 7:            #----------------> 'A OR NOT B' ;'B IMP A'
            r12 = np.logical_or(r_1, np.logical_not (r_2))
        elif b == 8:            #----------------> 'A NOR B'
            r12 = np.logical_not( (np.logical_or(r_1, r_2)))
        elif b == 9:            #----------------> 'A XOR B'
            r12 = np.logical_xor(r_1, r_2)
        elif b == 10:            #----------------> 'A EQV B'
            r12 = np.logical_not (np.logical_xor(r_1, r_2))
        else:
            print('Unknown Boolean function')

        rs[:, k] = r12
        k = k + 1


    return rs

def resp2pts(lab, resp):
    lab = lab > 0
    resp = resp > 0
    P = sum(lab)
    N = sum(~lab)
    if resp.ndim == 1:
        num_pts = 1
        tp = sum(lab[resp])
        fp = sum(~lab[resp])
    else:
        num_pts = resp.shape[1]
        tp = np.empty([num_pts,1])
        fp = np.empty([num_pts,1])
        for i in np.arange(num_pts):
            tp[i] = np.sum( lab[resp[:,i]]) 
            fp[i] = np.sum( ~lab[resp[:,i]])
    tp = np.true_divide(tp,P)
    fp = np.true_divide(fp,N)
    return fp, tp

Answer 1

我还没有实际测试过，但是我很确定这个减速是由重复使用np.vstack引起的。你不能真的附加到一个Numpy数组，所以如果你想增加大小，你必须首先分配一个新的数组，然后将新旧数据复制到其中。此过程需要时间：

A = np.random.rand(1e7)
%timeit A.copy()
10 loops, best of 3: 119 ms per loop

您的points_comb的大小会增加，因此复制它的时间会越来越长。在

解决方案是谨慎地附加到数组或使用Python列表（如果您事先不知道结果的大小）。在

所以不是：

^{pr2}$

例如，您可以：

result = list()

for i in some_iterable:
    for j in range(X):
        temp = somefunction(i,j)
        result.append(temp)

result_np = np.vstack(result)

不过，这个列表可能会占用大量内存。如果在循环之前知道结果的大小，则可以预先分配数组，并在数组可用时将内容复制到其中：

result = np.empty(shape=(X**2, N))

for i in range(X):
    for j in range(X):
        temp = somefunction(i,j)
        result[i*j, :] = temp

但你现在复制的速度很快。不过，最好的办法是将你的作品矢量化（我并不是说这是可能的）。然后你可以说再见，然后做一些类似的事情：

result = some_vectorized_function(X)