Сортировать столбцы массива на основе суммы

Question

Предположим, у меня есть массив как таковой:

np.array([1., 1., 0.],
       [0., 4., 0.],
       [8., 0., 8.],
       [0., 0., 0.],
       [5., 0., 0.],
       [2., 2., 2.]])

С столбцом [0], суммирующим до 16, столбцом [1] до 6 и столбцом [2] до 10.

Как эффективно в Numpy переупорядочить массив по значению столбца от наибольшего к наименьшему? В приведенном выше примере столбец [0] останется на месте, а столбец [1] и столбец [2] поменяются местами.

Answer 1

Замена двух последних столбцов выполняется следующим образом:

a = np.array([[1., 1., 0.],
             [0., 4., 0.],
             [8., 0., 8.],
             [0., 0., 0.],
             [5., 0., 0.],
             [2., 2., 2.]])

result = a[:, [0, 2, 1]]

Итак, вам нужно рассчитать эти индексы [0, 2, 1] на основе сумм столбцов.

Это дает вам суммы всех столбцов:

a.sum(axis=0)  # array([16.,  7., 10.])

и отсюда вы получаете индексы для сортировки:

np.argsort(np.array([16.,  7., 10.]))   # [1, 2, 0]

Вам нужно перевернуть его, чтобы получить порядок от наименьшего к низшему:

np.flip([1, 2, 0])   # [0, 2, 1]

Итак, все вместе, это:

result = a[:, np.flip(np.argsort(a.sum(axis=0)))]

Answer 2

Или вы можете использовать pandas:

>>> import pandas as pd, numpy as np
>>> arr=np.array([[1., 1., 0.],
       [0., 4., 0.],
       [8., 0., 8.],
       [0., 0., 0.],
       [5., 0., 0.],
       [2., 2., 2.]])
>>> df=pd.DataFrame(arr)
>>> df.sort_index(axis=1).values
array([[ 1.,  1.,  0.],
       [ 0.,  4.,  0.],
       [ 8.,  0.,  8.],
       [ 0.,  0.,  0.],
       [ 5.,  0.,  0.],
       [ 2.,  2.,  2.]])
>>> 

Answer 3

Вы можете сделать что-то вроде этого:

def main():
    a = np.array([[1., 1., 0.],
                 [0., 4., 0.],
                 [8., 0., 8.],
                 [0., 0., 0.],
                 [5., 0., 0.],
                 [2., 2., 2.]])
    col_sum = np.sum(a, axis=0)
    sort_index = np.argsort(-col_sum) # index sort in descending order
    out_matrix = a[:, sort_index]
    print(out_matrix)

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

Answer 4

Используя комбинацию np.sum и np.argsort, вы можете добиться этого следующим образом:

x = np.array([[1., 1., 0.],[0., 4., 0.],[8., 0., 8.],[0., 0., 0.],[5., 0., 0.],[2., 2., 2.]])
x[:, np.argsort(-np.sum(x, 0))]
array([[ 1.,  0.,  1.],
       [ 0.,  0.,  4.],
       [ 8.,  8.,  0.],
       [ 0.,  0.,  0.],
       [ 5.,  0.,  0.],
       [ 2.,  2.,  2.]])

Answer 5

Вы можете попробовать sum вдоль axis=0 и использовать argsort, затем перевернуть массив и использовать:

a[:,np.argsort(a.sum(axis=0))[::-1]]

array([[1., 0., 1.],
       [0., 0., 4.],
       [8., 8., 0.],
       [0., 0., 0.],
       [5., 0., 0.],
       [2., 2., 2.]])

Answer 6

arr = np.array([[1., 1., 0.],
                [0., 4., 0.],
                [8., 0., 8.],
                [0., 0., 0.],
                [5., 0., 0.],
                [2., 2., 2.]])

perm = np.flip(np.argsort(np.sum(arr, axis=0)))
result = a[:, perm]

Получить суммы; затем получить перестановку (массив индексов), которая сортирует суммы. argsort сортирует в порядке возрастания, поэтому поменяйте местами перестановку, чтобы мы получили индексы от самой высокой суммы до самой низкой. Наконец, измените порядок исходного массива с помощью той же перестановки.