Какие алгоритмы используются для сопоставления массива изображений с несколькими ядрами для обработки? Я пытался придумать что-то, что вернет список (непересекающихся) диапазонов, по которым итерация в массиве, и до сих пор у меня есть следующее.Разделить массив на подмассивы как можно более равномерным для отображения ядра
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
def divider(arr_dims, coreNum=1):
""" Get a bunch of iterable ranges;
Example input: [[[0, 24], [15, 25]]]
"""
if (coreNum == 1):
return arr_dims
elif (coreNum < 1):
raise ValueError(\
'partitioner expected a positive number of cores, got %d'\
% coreNum
)
elif (coreNum % 2):
raise ValueError(\
'partitioner expected an even number of cores, got %d'\
% coreNum
)
total = []
# Split each coordinate in arr_dims in _half_
for arr_dim in arr_dims:
dY = arr_dim[0][1] - arr_dim[0][0]
dX = arr_dim[1][1] - arr_dim[1][0]
if ((coreNum,)*2 > (dY, dX)):
coreNum = max(dY, dX)
coreNum -= 1 if (coreNum % 2 and coreNum > 1) else 0
new_c1, new_c2, = [], []
if (dY >= dX):
# Subimage height is greater than its width
half = dY // 2
new_c1.append([arr_dim[0][0], arr_dim[0][0] + half])
new_c1.append(arr_dim[1])
new_c2.append([arr_dim[0][0] + half, arr_dim[0][1]])
new_c2.append(arr_dim[1])
else:
# Subimage width is greater than its height
half = dX // 2
new_c1.append(arr_dim[0])
new_c1.append([arr_dim[1][0], half])
new_c2.append(arr_dim[0])
new_c2.append([arr_dim[1][0] + half, arr_dim[1][1]])
total.append(new_c1), total.append(new_c2)
# If the number of cores is 1, we get back the total; Else,
# we split each in total, etc.; it's turtles all the way down
return divider(total, coreNum // 2)
if __name__ == '__main__':
import numpy as np
X = np.random.randn(25 - 1, 36 - 1)
dims = [zip([0, 0], list(X.shape))]
dims = [list(j) for i in dims for j in dims[0] if type(j) != list]
print(divider([dims], 2))
Это невероятно ограничено, однако, поскольку он принимает только количество ядер, что некоторая степень 2, а затем я уверен, что есть крайние случаи, я с видом. Запуск он возвращает [[[0, 24], [0, 17]], [[0, 24], [17, 35]]], а затем с помощью pathos Я сопоставил первый набор с одним ядром в своем ноутбуке, а второй - с другим.
Я думаю, что я просто не знаю, как геометрически прокладывать себе путь путем разбиения изображения на сегменты, которые похожи на размер, насколько это возможно, так что каждое ядро на данной машине имеет такое же количество работы делать.
Я не совсем уверен, что вы пытаетесь сделать здесь (я не знаком с графической обработкой), но многопроцессорность python имеет концепцию «пула», в которой есть несколько работников, и вы можете отправлять каждому работнику например, партия 100 данных, которые он обрабатывает и возвращает, а затем ждет следующей партии. Таким образом, вам не нужно равномерно распределять задания по количеству доступных ядер, но вы можете просто отправить их в куски. Это поможет решить вашу проблему? – hansaplast