Вероятность повторной продажи одних и тех же предметов в фрейме данных pandas

Я считаю, что стандартный алгоритм совместной фильтрации будет выглядеть примерно так:

• сначала вам нужно сгруппировать ваши данные по sale_id и объединить значения в столбце элемента.
• Затем для каждой группы нужно создать набор предметов, которые были куплены вместе.
• Затем, наконец, вам нужно создать все возможные комбинации существующих элементов в виде набора и выполнить пересечение с вашими фактическими наборами элементов.

Это то, что все это выглядит для меня. Это должно иметь линейную пространственную сложность, и я уверен, что ее еще можно улучшить, но она может работать.

from itertools import combinations
import pandas as pd

df = pd.DataFrame({"sale_id": [1, 1, 1, 2, 2, 3, 3, 3, 3, 4],
              "item": ["A", "B", "C", "A", "C", "A", "D", "E", "C", "B"],
              "qty": [1, 4, 3, 2, 8, 3, 6, 5, 12, 9]})

# we don't care about quantity
df = df.loc[:, ['sale_id', 'item']]

# Get all the unique sets of items sold
grp = df.groupby('sale_id').transform(lambda x: ''.join(x))
purchases = grp['item'].apply(lambda x: ''.join(set(x))).unique()

# create all possible two-item pairs, then iterate over them
# adding 1 to the value of dictionary when the purchase
# matches the combination
unique_items = df.item.unique()
res = {}

for c in combinations(unique_items, 2):
    c = set(c)
    res[frozenset(c)] = 0
    for i in purchases:
        if c.intersection(i) == c:
            res[frozenset(c)] += 1

# get percentages
for k, v in res.items():
    res[k] = v / purchases.shape[0]

Выход:

{frozenset({'A', 'B'}): 0.25,
 frozenset({'A', 'C'}): 0.75,
 frozenset({'A', 'D'}): 0.25,
 frozenset({'A', 'E'}): 0.25,
 frozenset({'B', 'C'}): 0.25,
 frozenset({'B', 'D'}): 0.0,
 frozenset({'B', 'E'}): 0.0,
 frozenset({'C', 'D'}): 0.25,
 frozenset({'C', 'E'}): 0.25,
 frozenset({'D', 'E'}): 0.25}

Я решил найти чисто Pandas-способ ведения дел, и в итоге также довольно много оптимизировал метод Павла.

Прежде всего, что я делаю:

df = pd.DataFrame({"sale_id": [1, 1, 1, 2, 2, 3, 3, 3, 3, 4],
              "item": ["A", "B", "C", "A", "C", "A", "D", "E", "C", "B"],
              "qty": [1, 4, 3, 2, 8, 3, 6, 5, 12, 9]})
df.drop('qty', axis=1, inplace=True)

Затем начинается трассировка времени/памяти:

1. Единственный метод панд:

values = df.groupby('sale_id')['item'].agg(lambda x: [*combinations(sorted(x), 2)]).explode().value_counts()
denom = df['sale_id'].nunique()
output = (values/denom).reindex(combinations(df['item'].unique(), 2), fill_value=0)
output

Вывод, синхронизация и использование памяти:

(A, B)    0.25
(A, C)    0.75
(A, D)    0.25
(A, E)    0.25
(B, C)    0.25
(B, D)    0.00
(B, E)    0.00
(C, D)    0.25
(C, E)    0.25
(D, E)    0.25
Name: item, dtype: float64

475 µs ± 13.9 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

(End, Peek) Memory: (5442, 16440)

2. Оптимизированная версия метода Павла:

Единственные отличия заключаются в извлечении только item из groupby, поэтому создается Series, а не DataFrame, используется agg вместо transform и не используется set, поскольку после agg в этом нет необходимости.

grp = df.groupby('sale_id')['item'].agg(lambda x: ''.join(x))
purchases = grp.apply(lambda x: ''.join(x)).unique()
unique_items = df.item.unique()
res = {}
for c in combinations(unique_items, 2):
    c = set(c)
    res[frozenset(c)] = 0
    for i in purchases:
        if c.intersection(i) == c:
            res[frozenset(c)] += 1
for k, v in res.items():
    res[k] = v / purchases.shape[0]
res

Вывод, синхронизация и использование памяти:

{frozenset({'A', 'B'}): 0.25,
 frozenset({'A', 'C'}): 0.75,
 frozenset({'A', 'D'}): 0.25,
 frozenset({'A', 'E'}): 0.25,
 frozenset({'B', 'C'}): 0.25,
 frozenset({'B', 'D'}): 0.0,
 frozenset({'B', 'E'}): 0.0,
 frozenset({'C', 'D'}): 0.25,
 frozenset({'C', 'E'}): 0.25,
 frozenset({'D', 'E'}): 0.25}

276 µs ± 6.59 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

(End, Peek) Memory: (7643, 19402)

3. Оригинальный метод:

grp = df.groupby('sale_id').transform(lambda x: ''.join(x))
purchases = grp['item'].apply(lambda x: ''.join(set(x))).unique()
unique_items = df.item.unique()
res = {}
for c in combinations(unique_items, 2):
    c = set(c)
    res[frozenset(c)] = 0
    for i in purchases:
        if c.intersection(i) == c:
            res[frozenset(c)] += 1
for k, v in res.items():
    res[k] = v / purchases.shape[0]
res

Использование времени и памяти:

1.01 ms ± 30.6 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

(End, Peek) Memory: (15847, 27630)

Использовались следующие методы: %timeit в блокноте Jupyter и tracemalloc для трассировки памяти.