Python 大型阵列中元素的并行重新分配

我有一个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)

chop_preds=chop_preds.flatten（）
对于范围内的k（len（chop_preds））：
如果（chop_preds[k]>=0.4）：
chop_preds[k]=1.0
elif（chop_preds[k]如果
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 = ((chop_preds_flat >= 0.4) + 0.5 * ((chop_preds_flat >= 0.1) & (chop_preds_flat < 0.4))).sum()

my_sum=（（削去前额>=0.4）+0.5*（（削去前额>=0.1）和（削去前额>=0.4））。sum（）

在这三种方式中，
numpy.count\u nonzero
似乎是最快的：


相比之下，原始实现在该绘图上的最后一次输入大约需要0.2秒，因此比最差的
numpy
实现长约20倍（比最快的实现长约100倍）。
对于多处理，可以使用可以使用pip安装的“pathos”（）包

在你的情况下，我会尝试以下方式：

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

从paths.multiprocessing导入ProcessingPool作为池
def斩波器（值）：
如果（值>=0.4）：
值=1.0
elif（值<0.1）：
值=0
其他：
值=0.5
返回
chop_preds=chop_preds.flatten（）
#-------------------------------------------------------------设置
pass；from zmq import Stopwatch；aClock=Stopwatch（）；aPrintMASK=“在[{1:>12d}]大小的数组上完成关键部分需要{0:>12d}[us]
#-------------------------------------------------------------第节至测试：
通过；aClock.start（）
#----------------
myPool=Pool（8）#假设您有8个cpu核的机器
myPool.地图（切碎机，切碎机）
#----------------
通过；D=aClock.stop（）
pass；打印aPrintMASK.format（D，chop_preds.shape[0]）
#-------------------------------------------------------------端到端
值得一提的是，在我的macbook上，读取10M元素数组中的每个元素，然后为每个元素分配一个整数，以1.2s的速度连续运行。根据您的使用情况，可能没有理由麻烦您。不幸的是，这只是较大代码的一小部分，需要为许多不同的
chop_pred
重复这一部分ppet，一旦重复，我的程序需要8分钟中的7分钟才能运行，我还没有将它放大。这是非常快的！聪明！希望你不会介意我们-解决方案计时工具。如果目标是更好的性能，您是否介意在您的机器上重新运行并基准化您的方案，以便使概念在数量上与其他方法相比较？
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