Analiza koszykowa

 

Analiza koszykowa, opiera się o analizę historii zakupów w celu zrozumienia, jakie produktu kupowane są często razem. Tego typu reguły, są stosowane aby rekomendować, obecnym klientom, nabycie dodatkowych produktów i usług, które być może sami by nie kupili, ale podsuwając trafną sugestię, już tak. Poniżej zobaczymy, na czym to dokładnie polega, i jak taką analizę wykonać w Python.

 

Każdy z nas, styka się z tym kilka razy dziennie. Klasyczny przykład, podawany od dawna, to Amazon. W momencie kiedy oglądamy produkty, lub dodamy je do koszyka, przedstawiane / rekomendowane są nam dodatkowe produkty do kupienia.

 

Przykładowo, dodaliśmy do koszyka grzebień do włosów, tak więc może nam się wyświetlić oferta szamponu.

 

Tego typu rekomendacje, nazywa się cross-selling. Czyli do sprzedażą. Cały mechanizm opiera się na analizie wcześniejszych zakupów, a dokładnie, produktów które były kupione razem. Jeżeli występuje częsta sytuacja, że klienci, którzy nabywają grzebienie, kupują również szampony, uzasadnione jest przedstawienie oferty kupna szamponu, dla tego kto ma w koszyku zakupowym grzebień.

 

Takie reguły, nazywa się regułami asocjacyjnymi. Sklepy internetowe, czy też zakupu, to jedno z ich praktycznych zastosowań.

 

Bardzo często, przedstawia się je w taki sposób:

 

X -> Y

 

(chleb) -> (mleko)

 

(gazeta, zeszyt) -> (długopis)

 

Pierwsza reguła, mówi, że jeżeli ktoś chce kupić chleb, to prawdopodobnie kupi też mleko. Druga, że jeżeli ktoś chce kupić gazetę i zeszyt, to prawdopodobnie kupi też długopis.

 

Reguły asocjacyjne – podstawy

 

Zanim zaczniemy poszukiwania, naszych reguł asocjacyjnych, na podstawie listy zakupów, musimy poznać kilka podstawowych pojęć z nimi związanych. W szczególności sposób oceny, czy znaleziona przez nas reguła, jest warta uwagi czy też nie.

 

Dla uproszczenia, przyjmijmy, że mówimy o regule:

 

(cukierki) -> (mleko)

 

natomiast nasza historia zakupów wygląda następująco:

 

lista = pd.DataFrame({
        'mleko':[1,0,1,1,1,0,0,0,0,1],
        'chleb':[1,1,0,0,0,1,1,1,1,0],
        'ser':[0,1,0,0,0,0,1,1,1,1],
        'woda':[0,0,1,1,0,1,0,0,0,0],
        'cukierki':[0,0,1,0,0,1,0,0,0,1],
        'jabłka':[1,0,0,0,0,1,1,1,0,1],
        'gazeta':[1,0,1,1,0,0,0,1,1,0]})

lista

 

 

Poszczególne wiersze, odpowiadają paragonowi. Natomiast 0 oraz 1 mówią o tym, czy na tym paragonie został zakupiony chleb, cukierki itd.

 

Tak więc mamy 10 paragonów, czyli historię 10-ciu zakupów.

 

support (wsparcie)

 

support(cukierki,mleko) = (liczba transakcji w której występują razem cukierki i mleko) / (wszystkie transakcje)

 

Jest to miara, która mówi nam, jak często mamy do czynienia z zakupami, których występują cukierki i mleko. Im większa liczba, bym częstsze zjawisko

 

Wartość z zakresu (0,1)

 

W naszym przypadku – support(cukierki->mleko) = 2/10 = 0.2

 

confidence (zaufanie)

 

confidence = support(cukierki,mleko) / support (cukierki)

 

Miara, która mówi nam, czy kupno mleka, w przypadku kiedy były również kupowane cukierki, było przypadkiem czy nie. czym większa liczba, tym częściej ludzie którzy kupują cukierki, kupują również mleko. Jeżeli mała liczba, to znaczy, że ludzie którzy kupowali cukierki, często nie brali mleka.

 

Wartość z zakresu (0,1)

 

confidence (cukierki, mleko) = 0.2 / 0.3 = 0.66

 

lift (przyrost)

 

lift(cukierki, mleko) = support(cukierki,mleko) / (support(cukierki)*support(mleko))

 

Miara, która mówi nam ile razy częściej, cukierki i mleko, występują razem, niż gdyby były statystycznie niezależne.

 

liczba z zakresu od 0 do nieskończoności.

 

Lift = 1 – całkowity brak zależności pomiędzy zakupem cukierków i mleka

 

lift > 1 – pozytywna zależność

 

lift(cukierki, mleko) = 0.2 / (0.3 * 0.5) = 1.33

 

Wyznaczanie reguł asocjacyjnych, w Python

 

Skoro znamy już teorię, czas przejść do praktyki. Jedną z bibliotek w Python, która pomoże nam odnaleźć reguły asocjacyjne, jest mlxtend. Posiada ona zaimplementowaną metodę Apriori. Najbardziej popularną metodę wyznaczana reguł asocjacyjnych.

 

Instalacja oraz załadowanie bibliotek

 

Na początku musimy zainstalować naszą bibliotekę.

 

$ sudo pip install mlxtend

 

Następnie ładujemy niezbędne biblioteki:

 

import pandas as pd
from mlxtend.frequent_patterns import apriori, association_rules

 

Jak zwykle, wykorzystujemy Jupyter Notebook, aczkolwiek nie jest on wymagany i te same ćwiczenia, można swobodnie powtórzyć dowolnym edytorze tekstu.

 

Tworzymy naszą historie zakupów

 

lista = pd.DataFrame({
        'mleko':[1,0,1,1,1,0,0,0,0,1],
        'chleb':[1,1,0,0,0,1,1,1,1,0],
        'ser':[0,1,0,0,0,0,1,1,1,1],
        'woda':[0,0,1,1,0,1,0,0,0,0],
        'cukierki':[0,0,1,0,0,1,0,0,0,1],
        'jabłka':[1,0,0,0,0,1,1,1,0,1],
        'gazeta':[1,0,1,1,0,0,0,1,1,0]})

 

Sprawdzamy częstotliwość występowania różnych kombinacji

 

freq_items = apriori(lista, min_support=0.2, use_colnames=True)
freq_items.head(10)

 

 

Wykorzystaliśmy do tego celu funkcję apriori, z biblioteki mlxtend, a następnie wyświetliliśmy 10 pierwszych rekordów zbioru.

 

sprawdzamy reguły asocjacyjne, których mamy zaufanie większe niż 65%

 

rules = association_rules(freq_items, metric="confidence", min_threshold=0.65)
rules.head()

 

 

Użyliśmy do tego celu, drugiej funkcji z biblioteki mlxtend, mianowicie association_rules. Następnie wyświetliliśmy 5 pierwszych rekordów.

 

Tak jak widzimy, pierwszy rekord, jest to reguła, którą wyliczyliśmy wcześniej ‚ręcznie’, z wartościami support, confidence oraz lift, równymi wartościom których się spodziewaliśmy.

 

wybieramy reguły asocjacyjne

 

W rzeczywistości często wybieramy reguły, do których mamy duże przekonanie. Czyli preferujemy confidence, a nie support.

 

rules.sort_values(by='confidence', ascending=False).head()

 

 

Możemy pokusić się jeszcze o szybko wizualizację znalezionych reguł pod kątem confidence oraz lift

 

 rules["rule"] = rules["antecedents"].apply(lambda x: ', '.join(list(x))).astype("unicode") + \
        '->' + rules["consequents"].apply(lambda x: ', '.join(list(x))).astype("unicode") 

import seaborn as sns
import matplotlib.pyplot as plt

sns.set_context('paper')
sns.catplot(data=rules,
           x = "confidence",
           y = "lift",
           aspect = 1.5,
           hue = "rule")
plt.show()

 

 

Podsumowując.

 

Analiza koszykowa, to szybka i sprawdzona metoda zwiększenia sprzedaży. Może służyć, do rozplanowania ułożenia towaru w sklepie, budowy silników rekomendacji w serwisach transakcyjnych, czy też jako baza do działań sprzedażowych call center.

 

Biblioteka mlxtend, z drugiej strony, dostarcza nam przyjazną implementację metody apriori, i tak długo jak znamy, podstawowe pojęcia, jak support, confidence czy też lift, znalezienie odpowiednich reguł jest łatwe i szybkie.

 

Dodatkowe zasoby