python - 在 python 中使用多处理优化大数组的处理

Question

我有一个大型数据数组(大约一百万行)，其中每行都包含一个数量的坐标。我在 scipy.spatial 中使用 KDtree 算法将这些坐标分组到预定义的单元格中并附加单元格编号。在每行的末尾。我正在使用 multiprocessing.pool 来处理数组切片。没有。切片数等于否。系统核心数。该代码的处理时间大约需要一分钟。我可以通过一些修改来提高速度吗？或者我已经达到了极限。我必须处理大约 900 个这样的数组，所以时间在这里非常重要;)

我的代码的相关部分如下，

  #function called by external code
  def AnodeAssignment(sim_data_dir,filename,energy_data_dir):
      argv = sim_data_dir + filename
      global data
      data = np.loadtxt(argv,str,usecols=(0,2,5,6,8,9)) #load the array from file
      good  = np.where(data[:,2]=='phot')
      data = data[good]
      data = np.delete(data,2,1).astype(float)
      slice_width = data.shape[0]/multiprocessing.cpu_count()
      #slice array based on no. of core
      data_slice = []
      for i in range(multiprocessing.cpu_count()):
         data_slice.append(data[i*slice_width:(i+1)*slice_width])
      data_slice = np.array(data_slice)
      #pool processes 
      pool = multiprocessing.Pool()
      results = pool.map(pool_process,data_slice)
      pool.close()
      data = results[0]
      for i in range(1,multiprocessing.cpu_count()): #combine results
         data = np.vstack((data,results[i]))

  #function to process each slice using KDtree algo.
  def pool_process(data_slice):
      y = np.linspace(-19.5, 19.5, 14 ,endpoint=True)
      z = np.linspace(-9, 6, 6, endpoint=True)
      yv, zv = np.meshgrid(y,z)
      tree = spatial.KDTree(zip(yv.ravel(),zv.ravel()))
      dist, indices = tree.query(data_slice[:,3:])
      zz = tree.data[indices][:,1]
      yy = tree.data[indices][:,0]

      anode = np.ndarray((data_slice[:,0].size,1),int)

      a1  = np.where(np.logical_and(np.in1d(yy,y[1:-1:2]),np.in1d(zz ,[6])))
      a2  = np.where(np.logical_and(np.in1d(yy,y[2:-1:2]),np.in1d(zz ,[6])))
      a3  = np.where(np.logical_and(np.in1d(yy,y[1:-1:2]),np.in1d(zz ,[3])))
      a4  = np.where(np.logical_and(np.in1d(yy,y[2:-1:2]),np.in1d(zz ,[3])))
      a5  = np.where(zz==0)
      a6  = np.where(zz==-3)
      a7  = np.where(zz==-6)
      a8  = np.where(yy==-19.5)
      a9  = np.where(zz==-9)
      a10 = np.where(yy==19.5)

      anode[a1]  = 1
      anode[a2]  = 2
      anode[a3]  = 3
      anode[a4]  = 4
      anode[a5]  = 5
      anode[a6]  = 6
      anode[a7]  = 7
      anode[a8]  = 8
      anode[a9]  = 9
      anode[a10] = 10

      data_slice = np.hstack((data_slice,anode))
      return data_slice

Answer 1

如果计算可以并行完成，那么使用池是一个很好的步骤。 “暴力”类别的一个明显改进是借用具有更多内核的机器。 :-)以同样的方式，您可以使用机器集群。

在优化之前，您必须测量。在代码上使用分析器来查看它的时间都花在哪里了。然后看看是否可以采取不同的方法来加快速度。

话虽如此，一般来说，最大的改进通常是通过使用另一种算法来发现的。但由于我不知道你想在这里完成什么，所以我无法提供具体的建议。