Есть ли способ найти количество уникальных двоичных массивов в списке массивов?

Question

Если бы у меня был массив numpy в виде

[[0. 1. 1. 1. 1.],
[1. 0. 0. 0. 0.], 
[1. 0. 0. 0. 0.],
[1. 0. 0. 0. 0.],
[1. 0. 0. 0. 0.],
[0. 1. 1. 1. 1.]]

, есть ли способ определить частоту этих двоичных массивов?

Используя приведенный выше пример, частоты будут примерно такими: [1.0.0.0.0] - 4, [0.1.1.1.1] - 2. Я пытался использовать np.unique, но это возвращает количество только уникальных чисел, которое не очень полезно в этом случае.

Answer 1

from collections import Counter

counts = Counter(map(tuple, arr))

map(tuple, arr) преобразует каждую строку массива в кортеж, который может быть хэшируемым и, следовательно, может храниться в отображении, таком как Counter.

Answer 2

Использование только numpy.

import numpy as np

b = np.array([[0, 1, 1, 1, 1,],
            [1, 0, 0, 0, 0,], 
            [1, 0, 0, 0, 0,],
            [1, 0, 0, 0, 0,],
            [1, 0, 0, 0, 0,],
            [0, 1, 1, 1, 1,]])

c = np.unique(b, axis=0, return_counts=True)
print(c)

возвращает:

(array([[0, 1, 1, 1, 1],
   [1, 0, 0, 0, 0]]), array([2, 4], dtype=int64))

Answer 3

Если в вашем массиве не более 64 столбцов, вы можете преобразовать строки в числа и затем считать с помощью np.unique:

import numpy as np

data = np.array([[0., 1., 1., 1., 1.],
                 [1., 0., 0., 0., 0.], 
                 [1., 0., 0., 0., 0.],
                 [1., 0., 0., 0., 0.],
                 [1., 0., 0., 0., 0.],
                 [0., 1., 1., 1., 1.]])
# Convert each row into an integer
b = 1 << np.arange(data.shape[1], dtype=np.uint64)
nums = (b * data.astype(np.uint64)).sum(1)
# Count occurrences
vals, counts = np.unique(nums, return_counts=True)
# Make result
result = {tuple(((v & b) != 0).astype(np.uint8)): c for v, c in zip(vals, counts)}
print(result)
# {(1, 0, 0, 0, 0): 4, (0, 1, 1, 1, 1): 2}

Answer 4

Другие люди давали вам ответы, но я просто хотел отметить, что если вы превратите внутреннюю часть в нечто вроде кортежа, как предлагали другие, np.unique действительно возвращает счет как 4-й аргумент возврата

Answer 5

Похоже, у вас нет опыта работы с текстом. Чтобы расширить свой кругозор, как насчет представления каждой строки в матрице как строки, то есть слова.

При работе со словами вы можете использовать хеш-таблицу (словарь), чтобы подсчитать, сколько раз любое слово использовалось в списке. Словари хранят так называемые Key-Value пары. Когда слово появляется впервые, оно становится уникальным Key. После этого, если вы введете в словарь слово, которое уже было просмотрено, оно будет определено как уже установленное на Key, и если это так, вы просто добавите Value для этого Key на единицу.

Если вы хотите создать уникальные комбинации двоичных чисел (0,1), посмотрите на «алгоритм вращающейся двери» Дональда Кнута.

Answer 6

Не могли бы вы попробовать:

arrays = [[0. 1. 1. 1. 1.],
[1. 0. 0. 0. 0.], 
[1. 0. 0. 0. 0.],
[1. 0. 0. 0. 0.],
[1. 0. 0. 0. 0.],
[0. 1. 1. 1. 1.]]
print(len(set([tuple(i) for i in arrays])))

При этом удаляются дубликаты, а затем измеряется длина результата.