numpy python быстро и эффективно поднимает ненулевые значения на вершину двумерного массива

Question

Извините за название, я бы искал предложение, если у кого-то есть лучшее описание.Мне нужна функция (максимально быстрая), которая получает ненулевые записи и заполняет новый массив упорядоченной версией предыдущего массива.Это, вероятно, яснее из приведенного ниже примера:

Массив ввода

np.random.seed(2)
a = np.random.randint(0,10,10)
b = np.random.randint(0,10,10)
c = np.random.randint(0,10,10)
a = 0 * (a % 2) + (1-(a % 2))*a
b = 0 * (b % 2) + (1-(b % 2))*b
c = 0 * (c % 2) + (1-(c % 2))*c
arr = np.array([a,b,c])

arr
>>> array([[8, 8, 6, 2, 8, 0, 2, 0, 0, 4],
           [4, 0, 0, 0, 6, 4, 0, 0, 6, 0],
           [0, 0, 8, 4, 6, 0, 0, 2, 0, 4]])

Массив вывода

outArr = np.empty_like(arr)
outArr[0,:] = (arr[0,:] > 0) * arr[0,:] + ~(arr[0,:] > 0) * (arr[1,:] > 0) * arr[1,:] + ~(arr[0,:] > 0) * ~(arr[1,:] > 0) * arr[2,:]
outArr[1,:] = (arr[0,:] > 0) * arr[1,:] + (arr[0,:] > 0) * ~(arr[1,:] > 0) * arr[2,:]
outArr[2,:] = (arr[0,:] > 0) * (arr[1,:] > 0) * arr[2,:]

outArr
>>> array([[8, 8, 6, 2, 8, 4, 2, 2, 6, 4],
           [4, 0, 8, 4, 6, 0, 0, 0, 0, 4],
           [0, 0, 0, 0, 6, 0, 0, 0, 0, 0]])

ГдеЯ жестко запрограммировал этот массив только в 3 строки, чтобы я мог вручную ввести функцию, в действительности это может быть больше строк (порядка десятков, ничего особенного).

РЕДАКТИРОВАТЬ:

Размеры, которые я на самом деле хотел бы использовать, - это 5 строк по 100-150 тыс. Столбцов

Тип данных всегда будет целым числом

Наконец, процесс обновления - это Iдобавить новую строку внизу, выровнять вверх, а затем удалить все конечные строки только с 0 (нулевые значения)

Answer 1

Подход № 1

Вдохновленный justify, вот один, точно настроенный для up-justification и для случаев, когда сортировка может замедлить работу, поэтому можно предложить альтернативный вариант с broadcasted-mask-creation -

def justify_up(a, invalid_val=0, use_sort=True):
    if invalid_val is np.nan:
        mask = ~np.isnan(a)
    else:
        mask = a!=invalid_val

    if use_sort==1:
        justified_mask = np.sort(mask,axis=0)[::-1]
    else:
        justified_mask = (mask.sum(0) > np.arange(a.shape[0])[:,None])

    if invalid_val is 0:
        out = np.zeros_like(a)
    elif invalid_val is 1:
        out = np.ones_like(a)
    else:
        out = np.full(a.shape, invalid_val)

    out.T[justified_mask.T] = a.T[mask.T]
    return out

Пробный прогон -

In [199]: arr
Out[199]: 
array([[8, 8, 6, 2, 8, 0, 2, 0, 0, 4],
       [4, 0, 0, 0, 6, 4, 0, 0, 6, 0],
       [0, 0, 8, 4, 6, 0, 0, 2, 0, 4]])

In [200]: justify_up(arr, invalid_val=0)
Out[200]: 
array([[8, 8, 6, 2, 8, 4, 2, 2, 6, 4],
       [4, 0, 8, 4, 6, 0, 0, 0, 0, 4],
       [0, 0, 0, 0, 6, 0, 0, 0, 0, 0]])

Подход № 2

Мы также можем перенести работу с циклами на numba для производительности in-situ edit -

from numba import njit

@njit
def justify_up_numba(a, invalid_val=0):
    # invalid_val : Any number but NaN
    m,n = a.shape
    for j in range(m-1):
        for i in range(0,m-j-1):
            for k in range(n):
                if a[i,k]==invalid_val:
                    a[i,k] = a[i+1,k]
                    a[i+1,k] = invalid_val      
    return a

Синхронизация большого массива -

In [361]: np.random.seed(0)
     ...: arr = np.random.randint(0,5,(10,100000))

In [362]: %timeit justify_up(arr, invalid_val=0, use_sort=False)
100 loops, best of 3: 10.9 ms per loop

In [363]: %timeit justify_up(arr, invalid_val=0, use_sort=True)
100 loops, best of 3: 15.9 ms per loop

In [364]: %timeit justify_up_numba(arr, invalid_val=0)
100 loops, best of 3: 2.38 ms per loop