Numpy: поиск минимальных и максимальных значений из ассоциаций посредством биннинга

Предпосылка

Этот вопрос взят из этого сообщения. Итак, часть введения проблемы будет похожа на этот пост.

Проблема

Допустим, result — это двумерный массив, а values — это одномерный массив. values содержит некоторые значения, связанные с каждым элементом в result. Отображение элемента из values в result сохраняется в x_mapping и y_mapping. Позиция в result может быть связана с разными значениями. Теперь мне нужно найти минимум и максимум значений, сгруппированных по ассоциациям.

Пример для лучшего пояснения.

min_result массив:

[[0, 0],
[0, 0],
[0, 0],
[0, 0]]

max_result массив:

[[0, 0],
[0, 0],
[0, 0],
[0, 0]]

values массив:

[ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.]

Примечание. Здесь массивы result и values имеют одинаковое количество элементов. Но это может быть не так. Между размерами вообще нет никакой связи.

x_mapping и y_mapping имеют сопоставления от 1D values до 2D result (как минимум, так и максимум). Размеры x_mapping, y_mapping и values будут одинаковыми.

x_mapping - [0, 1, 0, 0, 0, 0, 0, 0]

y_mapping - [0, 3, 2, 2, 0, 3, 2, 1]

Здесь 1-е значение (values[0]) и 5-е значение (values[4]) имеют x как 0 и y как 0 (x_mapping[0] и y_mappping[0]) и, следовательно, связаны с result[0, 0]. Если мы вычислим минимум и максимум из этой группы, мы получим 1 и 5 результатов соответственно. Итак, у min_result[0, 0] будет 1, а у max_result[0, 0] будет 5.

Обратите внимание, что если связи вообще нет, то значение по умолчанию для result будет равно нулю.

Текущее рабочее решение

x_mapping = np.array([0, 1, 0, 0, 0, 0, 0, 0])
y_mapping = np.array([0, 3, 2, 2, 0, 3, 2, 1])
values = np.array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.], dtype=np.float32)
max_result = np.zeros([4, 2], dtype=np.float32)
min_result = np.zeros([4, 2], dtype=np.float32) 
min_result[-y_mapping, x_mapping] = values # randomly initialising from values
for i in range(values.size):
    x = x_mapping[i]
    y = y_mapping[i]
    # maximum
    if values[i] > max_result[-y, x]:
        max_result[-y, x] = values[i]
    # minimum
    if values[i] < min_result[-y, x]:
        min_result[-y, x] = values[i]

min_result,

[[1., 0.],
[6., 2.],
[3., 0.],
[8., 0.]]

max_result,

[[5., 0.],
[6., 2.],
[7., 0.],
[8., 0.]]

Неудачные решения

#1

min_result = np.zeros([4, 2], dtype=np.float32)
np.minimum.reduceat(values, [-y_mapping, x_mapping], out=min_result)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-126de899a90e> in <module>()
1 min_result = np.zeros([4, 2], dtype=np.float32)
----> 2 np.minimum.reduceat(values, [-y_mapping, x_mapping], out=min_result)

ValueError: object too deep for desired array

#2

min_result = np.zeros([4, 2], dtype=np.float32)
np.minimum.reduceat(values, lidx, out= min_result)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-24-07e8c75ccaa5> in <module>()
1 min_result = np.zeros([4, 2], dtype=np.float32)
----> 2 np.minimum.reduceat(values, lidx, out= min_result)

ValueError: operands could not be broadcast together with remapped shapes [original->remapped]: (4,2)->(4,) (8,)->() (8,)->(8,) 

#3

lidx = ((-y_mapping) % 4) * 2 + x_mapping #from mentioned post
min_result = np.zeros([8], dtype=np.float32)
np.minimum.reduceat(values, lidx, out= min_result).reshape(4,2)

[[1., 4.],
[5., 5.],
[1., 3.],
[5., 7.]]

Вопрос

Как использовать np.minimum.reduceat и np.maximum.reduceat для решения этой проблемы? Я ищу решение, оптимизированное для среды выполнения.

Примечание

Я использую Numpy версии 1.14.3 с Python 3.5.2.


person tpk    schedule 06.08.2018    source источник


Ответы (1)


Подход №1

Опять же, наиболее интуитивным будет использование numpy.ufunc.at. Теперь, поскольку эти сокращения будут выполняться против существующих значений, нам нужно инициализировать вывод с максимальными значениями для минимальных сокращений и минимальными значениями для максимальных. Следовательно, реализация будет -

min_result[-y_mapping, x_mapping] = values.max()
max_result[-y_mapping, x_mapping] = values.min()

np.minimum.at(min_result, [-y_mapping, x_mapping], values)
np.maximum.at(max_result, [-y_mapping, x_mapping], values)

Подход № 2

Чтобы использовать np.ufunc.reduceat, нам нужно отсортировать данные -

m,n = max_result.shape
out_dtype = max_result.dtype
lidx = ((-y_mapping)%m)*n + x_mapping

sidx = lidx.argsort()
idx = lidx[sidx]
val = values[sidx]

m_idx = np.flatnonzero(np.r_[True,idx[:-1] != idx[1:]])
unq_ids = idx[m_idx]

max_result_out.flat[unq_ids] = np.maximum.reduceat(val, m_idx)
min_result_out.flat[unq_ids] = np.minimum.reduceat(val, m_idx)
person Divakar    schedule 06.08.2018
comment
np.minimum.at(min_result, [-y_mapping, x_mapping], values) приведет к нулевому массиву, если мы инициализируем min_result как ноль. Любое обходное решение, кроме min_result[min_result == MAX_VALUE] = 0.0? - person tpk; 06.08.2018
comment
Второй подход намного быстрее, чем первый. Любые идеи? - person tpk; 06.08.2018
comment
@tpk То же, что и в предыдущем вопросе. ufunc.at, вероятно, зацикливаются под капотом, а ufunc.reduceat - нет. - person Divakar; 06.08.2018
comment
можно и этот вопрос изучить? stackoverflow.com/questions/53513497/ - person tpk; 28.11.2018