Есть ли способ векторизовать подсчет совпадений предметов в pandas / numpy? - PullRequest
0 голосов
/ 23 октября 2019

Мне часто нужно генерировать сетевые графики на основе совпадений элементов в столбце. Я начинаю с чего-то вроде этого:

           letters
0  [b, a, e, f, c]
1        [a, c, d]
2        [c, b, j]

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

В настоящее время я делаю большие его части, используя цикл for, и мне было интересно, есть ли способ для его векторизации, поскольку я часто имею дело с огромными наборами данных, обработка которых занимает очень много временитаким образом. Я также обеспокоен хранением вещей в пределах памяти. Это мой код прямо сейчас:

import pandas as pd

# Make some data
df = pd.DataFrame({'letters': [['b','a','e','f','c'],['a','c','d'],['c','b','j']]})

# I make a list of sets, which contain pairs of all the elements
# that co-occur in the data in the same list
sets = []
for lst in df['letters']:
    for i, a in enumerate(lst):
        for b in lst[i:]:
            if not a == b:
                sets.append({a, b})

# Sets now looks like:
# [{'a', 'b'},
#  {'b', 'e'},
#  {'b', 'f'},...

# Dataframe with one column containing the sets
df = pd.DataFrame({'weight': sets})

# We count how many times each pair occurs together
df = df['weight'].value_counts().reset_index()

# Split the sets into two seperate columns
split = pd.DataFrame(df['index'].values.tolist()) \
          .rename(columns = lambda x: f'Node{x+1}') \
          .fillna('-')

# Merge the 'weight' column back onto the dataframe
df = pd.concat([df['weight'], split], axis = 1)

print(df.head)

# Output:
   weight Node1 Node2
0       2     c     b
1       2     a     c
2       1     f     e
3       1     d     c
4       1     j     b

Ответы [ 3 ]

2 голосов
/ 23 октября 2019

Решение для numpy / scipy, использующее матрицы разреженных инцидентов:

from itertools import chain
import numpy as np
from scipy import sparse
from simple_benchmark import BenchmarkBuilder, MultiArgument

B = BenchmarkBuilder()

@B.add_function()
def pp(L):
    SZS = np.fromiter(chain((0,),map(len,L)),int,len(L)+1).cumsum()
    unq,idx = np.unique(np.concatenate(L),return_inverse=True)
    S = sparse.csr_matrix((np.ones(idx.size,int),idx,SZS),(len(L),len(unq)))
    SS = (S.T@S).tocoo()
    idx = (SS.col>SS.row).nonzero()
    return unq[SS.row[idx]],unq[SS.col[idx]],SS.data[idx] # left, right, count


from collections import Counter
from itertools import combinations

@B.add_function()
def yatu(L):
    return Counter(chain.from_iterable(combinations(sorted(i),r=2) for i in L))

@B.add_function()
def feature_engineer(L):
    Counter((min(nodes), max(nodes))
            for row in L for nodes in combinations(row, 2))

from string import ascii_lowercase as ltrs

ltrs = np.array([*ltrs])

@B.add_arguments('array size')
def argument_provider():
    for exp in range(4, 30):
        n = int(1.4**exp)
        L = [ltrs[np.maximum(0,np.random.randint(-2,2,26)).astype(bool).tolist()] for _ in range(n)]
        yield n,L

r = B.run()
r.plot()

enter image description here

Мы видим, что здесь представлен метод (pp)с типичными значениями numpy константы, но из ~ 100 списков он начинает побеждать.

Пример OP:

import pandas as pd

df = pd.DataFrame({'letters': [['b','a','e','f','c'],['a','c','d'],['c','b','j']]})
pd.DataFrame(dict(zip(["left", "right", "count"],pp(df['letters']))))

Печать:

   left right  count
0     a     b      1
1     a     c      2
2     b     c      2
3     c     d      1
4     a     d      1
5     c     e      1
6     a     e      1
7     b     e      1
8     c     f      1
9     e     f      1
10    a     f      1
11    b     f      1
12    b     j      1
13    c     j      1
1 голос
/ 23 октября 2019

Для повышения производительности вы можете использовать itertooos.combinations для получения всех комбинаций длины 2 из внутренних списков и Counter для подсчета пар в сплющенном списке.

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

from itertools import combinations, chain
from collections import Counter

l = df.letters.tolist()
t = chain.from_iterable(combinations(sorted(i), r=2) for i in l)

print(Counter(t))

Counter({('a', 'b'): 1,
         ('a', 'c'): 2,
         ('a', 'e'): 1,
         ('a', 'f'): 1,
         ('b', 'c'): 2,
         ('b', 'e'): 1,
         ('b', 'f'): 1,
         ('c', 'e'): 1,
         ('c', 'f'): 1,
         ('e', 'f'): 1,
         ('a', 'd'): 1,
         ('c', 'd'): 1,
         ('b', 'j'): 1,
         ('c', 'j'): 1})
1 голос
/ 23 октября 2019

Примечания:

Как предлагается в других ответах, используйте collections.Counter для подсчета. Так как он ведет себя как dict, ему требуются хешируемые типы. {a,b} не хэшируемый, потому что это набор. Замена его на кортеж устраняет проблему с хэш-памятью, но вводит возможные дубликаты (например, ('a', 'b') и ('b', 'a')). Чтобы решить эту проблему, просто сортируйте кортеж.

, поскольку sorted возвращает list, нам нужно превратить это обратно в кортеж: tuple(sorted((a,b))). Немного громоздко, но удобно в сочетании с Counter.

Быстрое и простое ускорение: понимание вместо циклов

При перестановке ваши вложенные циклы можно заменить следующим пониманием:

sets = [ sorted((a,b)) for lst in df['letters'] for i,a in enumerate(lst) for b in lst[i:] if not a == b ]

В Python есть оптимизация для выполнения понимания, так что это уже принесет некоторое ускорение.

Бонус: если вы объедините его с Counter, вам даже не понадобится результат в виде списка, но вместо этого вы можете использовать выражение генератора (вместо этого почти не используется дополнительная памятьхранения всех пар):

Counter( tuple(sorted((a, b))) for lst in lists for i,a in enumerate(lst) for b in lst[i:] if not a == b ) # note the lack of [ ] around the comprehension

Оценка: Каков более быстрый подход?

Как обычно, когда речь идет о производительности, окончательный ответ должен прийти из тестирования различных подходов ивыбирая лучший. Здесь я сравниваю (очень элегантный и читабельный) подход на основе itertools от @yatu, оригинальную вложенность и понимание. Все тесты выполняются на одних и тех же данных примера, сгенерированных случайным образом в соответствии с приведенным примером.

from timeit import timeit

setup = '''
import numpy as np
import random
from collections import Counter
from itertools import combinations, chain
random.seed(42)
np.random.seed(42)

DF_SIZE = 50000 # make it big
MAX_LEN = 6
list_lengths = np.random.randint(1, 7, DF_SIZE)

letters = 'abcdefghijklmnopqrstuvwxyz'

lists = [ random.sample(letters, ln) for ln in list_lengths ] # roughly equivalent to df.letters.tolist()
'''

#################

comprehension = '''Counter( tuple(sorted((a, b))) for lst in lists for i,a in enumerate(lst) for b in lst[i:] if not a == b )'''
itertools = '''Counter(chain.from_iterable(combinations(sorted(i), r=2) for i in lists))'''
original_for_loop = '''
sets = []
for lst in lists:
    for i, a in enumerate(lst):
        for b in lst[i:]:
            if not a == b:
                sets.append(tuple(sorted((a, b))))
Counter(sets)
'''

print(f'Comprehension: {timeit(setup=setup, stmt=comprehension, number=10)}')
print(f'itertools: {timeit(setup=setup, stmt=itertools, number=10)}')
print(f'nested for: {timeit(setup=setup, stmt=original_for_loop, number=10)}')

При запуске приведенного выше кода на моем компьютере (python 3.7) печатается:

Comprehension: 1.6664735930098686
itertools: 0.5829475829959847
nested for: 1.751666523006861

Итакоба предложенных подхода улучшены по сравнению с вложенными циклами for, но в этом случае itertools действительно быстрее.

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...