Question

我有一个大型数据阵列（大约百万行），其中每一行都包含一个数量的坐标。我在scipy.spatial中使用KDtree算法将这些坐标分组到预定义的单元格中，并附加单元格no。在每一行的末尾。我正在使用mulitprocessing.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

如果可以并行计算，使用Pool是一个很好的步骤。 “蛮力”类别的一个明显改进是借用具有更多核心的机器。 :-) 以同样的方式，您可以使用一组机器。

在优化之前，您必须衡量。在代码上使用分析器查看它花费时间的位置。然后看看你是否能以不同的方式做事以使其更快。

话虽如此，通常通过使用另一种算法可以找到最大的改进。但由于我不清楚你在这里想要完成什么，我无法提供具体的建议。

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

1 个答案: