Skip to main content
 首页 » 编程设计

python之邻域内不超过1个点的并行过滤方式

2025年01月19日11think

我有一个 23x23x30 的空间,每个 1x1x1 的立方体代表一个点,其中一些 23x23x30 点填充的数字范围为-65 到 -45,如果有多个点,我想确保在填充点周围 5x5x30 的任何给定区域中不应有超过 1 个数字在 5x5x30 的任何区域中,应消除数字最小的点。我已经使用嵌套的 for 循环以串行方式完成了此操作,但这是非常昂贵的操作。我想并行化这个操作。我有 n 个核心,每个核心在 23x23x30 的总区域中都有自己的子区域,没有任何重叠。我可以收集那些“子区域”并构建上面提到的 23x23x30 的完整区域,以便所有内核都可以同时访问 23x23x30 的完整区域他们的“子区域”也是如此。我不确定在 python 中是否有任何库可用于这种操作。在我的应用程序中,8 个进程将用大约 3500 点填充这个 23x23x30 空间,现在我正在对所有 8 个进程执行此“过滤”操作(即复制工作)这是资源浪费,所以我必须并行执行此“过滤”以便有效地使用可用资源。

这是串行代码:self.tntatv_stdp_ids 是一个字典,键为 step1,step2.... upto 30 维度中的步骤,z。此键具有该步骤中填充的点的编号(1 到 529)。请注意,在代码的串行实现中,z 维度中每个步骤中的点都是从 1 到 529。

self.cell_voltages 是一个字典,键为 step1、step2....最多 30 步骤维度,z。每个键给出一个点中出现的数字。

     a_keys = self.tntatv_stdp_ids.keys() 
 
    #Filter tentative neuron ids using suppression algo to come up with final stdp neuron ids.  
    for i in range(0,len(a_keys)): 
        b_keys= list(set(a_keys) - set([a_keys[i]])) 
        c_keys = self.tntatv_stdp_ids[a_keys[i]] 
 
        for j in range(0,len(b_keys)): 
            d_keys=self.tntatv_stdp_ids[b_keys[j]] 
            for k in c_keys[:]: 
                key = k  
                key_row= key/(image_size-kernel+1) 
                key_col = key%(image_size-kernel+1) 
                remove =0 
                for l in d_keys[:]: 
                    target = l  
                    tar_row = target/(image_size-kernel+1) 
                    tar_col = target%(image_size-kernel+1) 
 
                    if(abs(key_row-tar_row) > kernel-1 and abs(key_col-tar_col) > kernel-1): 
                        pass 
                    else: 
                        if(self.cell_voltages[a_keys[i]][key]>=self.cell_voltages[b_keys[j]][target]): 
                            d_keys.remove(target) 
                        else: 
                            remove+=1 
                if(remove): 
                    c_keys.remove(key) 

在此操作结束时,如果 23x23x1 的 30 区域中有多个剩余点数,则每个 30 23x23x1 区域可以通过查看 23x23x1 点的剩余填充点中哪些点的数量最多来选择。通过这种方式,23x23x30 中所有点的最大获胜者数量可以是 30,23x23x1 中每个点 1 个。也可以少于 30,这取决于开始时填充了多少 23x23x30 点。

请您参考如下方法:

这个问题不太可能需要并行化:

# Generate a random array of appropriate size for testing 
super_array = [[[None for _ in range(30)] for _ in range(529)] for _ in range(529)] 
for _ in range(3500): 
    super_array[random.randint(0, 528)][random.randint(0, 528)][random.randint(0,29)] = random.randint(-65, -45) 

第一步是构建一个填充节点列表:

filled = [] 
for x in range(len(super_array)): 
    for y in range(len(super_array[0])): 
        for z in range(len(super_array[0][0])): 
            if super_array[x][y][z] is not None: 
                filled.append((x, y, z, super_array[x][y][z])) 

然后,将列表从高到低排序:

sfill = sorted(filled, key=lambda x: x[3], reverse=True) 

现在,生成一个阻塞网格:

block_array = [[None for _ in range(529)] for _ in range(529)] 

然后遍历列表,在找到节点时封锁邻域并删除已占用邻域中的节点:

for node in sfill:  
    x, y, z, _ = node 
    if block_array[x][y] is not None: 
        super_array[x][y][z] = None  # kill node if it's in the neighborhood of a larger node 
    else: # Block their neighborhood 
        for dx in range(5): 
            for dy in range(5): 
                cx = x + dx - 2 
                cy = y + dy - 2 
                if 529 > cx >= 0 and 529 > cy >= 0: 
                    block_array[cx][cy] = True 

一些注意事项:

  • 这使用滑动邻域,因此它检查以每个节点为中心的 5x5。从最高到最低进行检查很重要,因为这可以确保被删除的节点之前没有强制删除其他节点。

  • 通过使用范围而不是完整的 529x529 数组,您可以更有效地做到这一点,但邻域阻塞花费的时间不到一秒,而从生成数组到修剪最终列表的整个过程仅需 1.2 秒。

  • 可以通过仅在任何 z 堆栈中添加最高值节点来改进填充节点列表的构建。如果大量节点最终具有相同的 x、y 值,这将减少必须排序的列表的大小。

在 23x23x30 上,大约需要 18 毫秒,同样包括构建 3d 数组的时间:

timeit.timeit(prune_test, number=1000) 
17.61786985397339