大数组中元素的并行重分配

Question

我有一个numpy数组chop_preds，它非常大（约1000万个元素），需要修改，使其包含1.0、0.5或0的值（见下文）。你知道吗

我怎样才能并行这次重新分配？你知道吗

chop_preds=chop_preds.flatten()

for k in range(len(chop_preds)):
    if(chop_preds[k]>=0.4):
        chop_preds[k]=1.0 
    elif(chop_preds[k]<0.1):
        chop_preds[k]=0 
    else:
        chop_preds[k]=0.5 

my_sum=np.sum(chop_preds)

Answer 1

如果chop_preds已经是numpy数组，则可以使用：

chop_preds_flat = chop_preds.flatten()
chop_preds = 0.5 * np.ones_like(chop_preds_flat)
chop_preds[chop_preds_flat >= 0.4] = 1.
chop_preds[chop_preds_flat < 0.1] = 0.

my_sum = chop_preds.sum()

或者，如果您真的只需要求和，请对这些选择使用^{}：

my_sum = 0.5 * np.count_nonzero((chop_preds_flat >= 0.1) & (chop_preds_flat < 0.4))
my_sum += np.count_nonzero(chop_preds_flat >= 0.4)

更简单，但更难阅读：

my_sum = ((chop_preds_flat >= 0.4) + 0.5 * ((chop_preds_flat >= 0.1) & (chop_preds_flat < 0.4))).sum()

在这三种方式中，numpy.count_nonzero似乎是最快的：

相比之下，原始实现在该图上的最后一个输入大约需要0.2秒，因此比最差的numpy实现长20倍（比最快的实现长100倍）。你知道吗

Answer 2

对于多处理，可以使用可以使用pip安装的“pathos”（github page）包。你知道吗

在你的情况下，我会这样做：

from pathos.multiprocessing import ProcessingPool as Pool

def chopper(value):
  if(value >= 0.4):
     value = 1.0 
  elif(value < 0.1):
    value = 0 
  else:
    value = 0.5
  return

chop_preds = chop_preds.flatten()
#                              -SETUP
pass;                                                         from zmq import Stopwatch; aClock = Stopwatch(); aPrintMASK = "The Critical Section took {0: > 12d} [us] to complete on [{1: >12d}] sized array"
#                              -SECTION-TO-TEST:
pass;                                                         aClock.start()
#        <_!_>
myPool = Pool(8)                   # assuming you have an 8 cpu cores machines
myPool.map(chopper,chop_preds)
#        <_!_>
pass;                                                         D = aClock.stop()
pass;                                                         print aPrintMASK.format( D, chop_preds.shape[0] )
#                              -SECTION-TO-TEST.End