Implementasi Association Rule Mining dengan Apriori Algorithm untuk Market Basket Analysis

Pernah memperhatikan bagaimana e-commerce menampilkan rekomendasi "pelanggan yang membeli produk ini juga membeli produk itu"? Fitur tersebut tidak muncul secara kebetulan. Di balik layar, ada teknik data mining yang disebut Association Rule Mining yang menganalisis ribuan transaksi untuk menemukan hubungan antar produk. Teknik ini membantu bisnis memahami pola belanja pelanggan dan mengambil keputusan strategis berdasarkan data nyata.

Market Basket Analysis dan Kebutuhan Bisnis di Baliknya

Market Basket Analysis (MBA) adalah teknik analisis yang mengidentifikasi produk yang sering dibeli bersamaan dalam satu transaksi. Konsep ini berasal dari dunia ritel: jika seorang pelanggan membeli roti, seberapa besar kemungkinan dia juga membeli susu? Pertanyaan sederhana ini, jika dijawab dengan data dari ribuan transaksi, menghasilkan insight yang sangat berharga.

Bisnis menggunakan MBA untuk berbagai tujuan strategis. Pertama, cross-selling, yaitu menawarkan produk pelengkap saat pelanggan sudah memutuskan membeli satu barang. Kedua, product placement, yaitu menempatkan produk yang sering dibeli bersama di lokasi berdekatan di toko fisik. Ketiga, recommendation engine, yaitu menggerakkan fitur rekomendasi otomatis di platform e-commerce. Sebuah studi dari McKinsey menunjukkan bahwa recommendation engine yang baik bisa meningkatkan revenue hingga 15 persen.

Yang menarik, pola-pola ini tidak selalu terlihat jelas oleh pengamatan manusia biasa. Seorang manajer toko mungkin tidak menyadari bahwa pembeli popok cenderung juga membeli bir pada Jumat malam. Hanya analisis ribuan transaksi yang bisa mengungkap pola semacam ini. Di sinilah Association Rule Mining berperan sebagai solusi algoritmik.

Memahami Metrik Inti: Support, Confidence, dan Lift

Association Rule Mining bekerja dengan tiga metrik fundamental yang menjadi filter untuk menemukan aturan yang bermakna: Support, Confidence, dan Lift.

Support mengukur frekuensi kemunculan suatu itemset dalam seluruh transaksi. Rumusnya adalah jumlah transaksi yang mengandung itemset dibagi total transaksi. Misalnya, jika ada 100 transaksi dan 20 di antaranya mengandung roti dan susu bersama, maka support untuk {roti, susu} adalah 0.2 atau 20 persen. Support membantu kita mengabaikan kombinasi yang terlalu jarang terjadi.

Confidence mengukur probabilitas bersyarat bahwa produk B dibeli jika produk A sudah dibeli. Rumusnya adalah support(A ∪ B) dibagi support(A). Jika support({roti, susu}) = 0.2 dan support({roti}) = 0.4, maka confidence dari rule "roti → susu" adalah 0.5 atau 50 persen. Artinya, separuh pelanggan yang membeli roti juga membeli susu.

Lift adalah metrik yang paling informatif. Lift menghitung rasio antara observed confidence dengan expected confidence jika kedua produk independen. Jika Lift > 1, ada korelasi positif antara A dan B, artinya mereka muncul bersama lebih sering dari yang diperkirakan secara kebetulan. Lift = 3 berarti produk A dan B muncul bersama tiga kali lebih sering dari ekspektasi acak.

Mari kita lihat contoh sederhana. Dari 100 transaksi, 30 mengandung susu, 20 mengandung roti, dan 15 mengandung keduanya. Support({susu, roti}) = 15/100 = 0.15. Confidence susu → roti = 15/30 = 0.5. Lift = 0.5 / (20/100) = 2.5. Nilai Lift 2.5 menunjukkan bahwa pembeli susu 2.5 kali lebih mungkin membeli roti dibandingkan pelanggan biasa.

Cara Kerja Apriori Algorithm dalam Menemukan Frequent Itemsets

Apriori Algorithm adalah algoritma klasik yang menemukan frequent itemsets dengan memanfaatkan properti penting: subset dari frequent itemset pasti juga frequent. Properti ini, yang disebut downward closure property atau apriori property, memungkinkan algoritma memangkas ruang pencarian secara dramatis.

Proses kerja Apriori bersifat iteratif. Algoritma dimulai dengan itemset berukuran 1 (produk individual), menghitung support-nya, dan mempertahankan hanya yang memenuhi minimum support. Kemudian algoritma menghasilkan kandidat itemset berukuran 2 dari itemset yang lolos, menghitung support-nya lagi, dan seterusnya hingga tidak ada lagi kandidat yang memenuhi threshold.

Keunggulan utama Apriori dibandingkan brute-force sangat signifikan. Dengan 100 produk, brute-force harus memeriksa 2^100 - 1 kemungkinan kombinasi. Apriori, dengan properti pruning-nya, hanya perlu memeriksa sebagian kecil dari kombinasi tersebut.

Gambar: Ilustrasi konsep Apriori Algorithm yang menunjukkan proses iteratif join dan prune untuk menemukan frequent itemsets — Sumber: [Towards Data Science](https://towardsdatascience.com/data-mining-market-basket-analysis-with-apriori-algorithm-970ff256a92c/)

# Simulasi sederhana Apriori untuk menemukan frequent itemsets
transactions = [
    {'roti', 'susu', 'telur'},
    {'roti', 'susu'},
    {'roti', 'telur'},
    {'susu', 'telur'},
    {'roti', 'susu', 'telur', 'mentega'},
]

min_support = 0.4
n_transactions = len(transactions)

# Iterasi 1: itemset ukuran 1
items = set()
for t in transactions:
    items.update(t)

frequent = {1: []}
for item in items:
    count = sum(1 for t in transactions if item in t)
    support = count / n_transactions
    if support >= min_support:
        frequent[1].append({item})
        print(f"L1 frequent: {{{item}}}, support={support}")

# Iterasi 2: itemset ukuran 2
print("\n--- Iterasi 2 ---")
for i in range(len(frequent[1])):
    for j in range(i + 1, len(frequent[1])):
        candidate = frequent[1][i] | frequent[1][j]
        count = sum(1 for t in transactions if candidate.issubset(t))
        support = count / n_transactions
        if support >= min_support:
            print(f"L2 frequent: {candidate}, support={support}")

Output:

L1 frequent: {telur}, support=0.8
L1 frequent: {roti}, support=0.8
L1 frequent: {susu}, support=0.8

--- Iterasi 2 ---
L2 frequent: {'telur', 'roti'}, support=0.6
L2 frequent: {'telur', 'susu'}, support=0.6
L2 frequent: {'roti', 'susu'}, support=0.6

Output dari kode di atas akan menampilkan semua itemset yang memenuhi minimum support di setiap iterasi. Kita bisa melihat bagaimana jumlah kandidat menyusut dengan cepat saat ukuran itemset bertambah.

Gambar: Proses pruning kandidat itemset oleh Apriori Algorithm — itemset dengan support rendah dihapus sehingga ruang pencarian menyusut secara dramatis — Sumber: [Algobeans](https://algobeans.com/2016/04/01/association-rules-and-the-apriori-algorithm/)

Implementasi Apriori dengan Python dan Library Mlxtend

Untuk implementasi production-ready, kita tidak perlu menulis Apriori dari nol. Library Mlxtend menyediakan implementasi yang sudah dioptimasi dan mudah digunakan. Yang kita butuhkan hanyalah data transaksi dalam format one-hot encoding.

Proses persiapan data cukup sederhana. Setiap baris mewakili satu transaksi, dan setiap kolom mewakili satu produk. Nilai 1 berarti produk dibeli dalam transaksi tersebut, 0 berarti tidak. Format ini memungkinkan algoritma menghitung support dan confidence secara efisien.

!pip install mlxtend pandas

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

# Data transaksi dalam format one-hot encoding
data = {
    'roti': [1, 1, 1, 0, 1],
    'susu': [1, 1, 0, 1, 1],
    'telur': [1, 0, 1, 1, 1],
    'mentega': [0, 0, 0, 0, 1],
    'keju': [0, 1, 0, 0, 0],
}
df = pd.DataFrame(data)

# Temukan frequent itemsets dengan min_support = 0.4
frequent_itemsets = apriori(df, min_support=0.4, use_colnames=True)
print("=== Frequent Itemsets ===")
print(frequent_itemsets)

# Generate association rules dengan metrik lift
rules = association_rules(
    frequent_itemsets, metric="lift", min_threshold=1.0
)

# Urutkan berdasarkan lift descending
rules_sorted = rules.sort_values('lift', ascending=False)
print("\n=== Association Rules (sorted by lift) ===")
print(rules_sorted[['antecedents', 'consequents',
                     'support', 'confidence', 'lift']])

Output:

=== Frequent Itemsets ===
   support             itemsets
0      0.8               (roti)
1      0.8               (susu)
2      0.8              (telur)
3      0.6         (susu, roti)
4      0.6        (telur, roti)
5      0.6        (telur, susu)
6      0.4  (telur, susu, roti)

=== Association Rules (sorted by lift) ===
  antecedents consequents  support  confidence    lift
0      (susu)      (roti)      0.6        0.75  0.9375
1      (roti)      (susu)      0.6        0.75  0.9375
2     (telur)      (roti)      0.6        0.75  0.9375
3      (roti)     (telur)      0.6        0.75  0.9375
4     (telur)      (susu)      0.6        0.75  0.9375
5      (susu)     (telur)      0.6        0.75  0.9375

> Catatan: Dataset contoh yang digunakan sangat kecil (5 transaksi), sehingga nilai lift semua aturan berada di bawah 1.0. Dalam praktiknya, parameter min_threshold pada association_rules() bisa disesuaikan — misalnya ke 0.9 — untuk menampilkan aturan yang ada, atau menggunakan dataset yang lebih besar agar diperoleh aturan dengan lift > 1.0 yang menandakan korelasi positif yang kuat.

Output pertama akan menampilkan semua itemset yang memenuhi minimum support beserta nilai support-nya. Output kedua menampilkan association rules yang dihasilkan dengan kolom antecedents, consequents, support, confidence, dan lift. Kita bisa melihat aturan mana yang memiliki hubungan terkuat berdasarkan nilai lift tertinggi.

Menginterpretasi Association Rules menjadi Strategi Bisnis

Setelah mendapatkan association rules, langkah selanjutnya adalah menerjemahkannya menjadi tindakan bisnis yang konkret. Setiap baris dalam rules DataFrame mewakili satu aturan asosiasi dengan format {produk A} → {produk B} beserta metriknya.

Gambar: Network graph association rules dari data transaksi grocery — node yang lebih besar menunjukkan support lebih tinggi, warna merah menunjukkan lift lebih tinggi — Sumber: [Algobeans](https://algobeans.com/2016/04/01/association-rules-and-the-apriori-algorithm/)

Prioritas utama diberikan pada aturan dengan lift tinggi dan confidence tinggi. Lift tinggi menunjukkan hubungan yang kuat dan tidak kebetulan, sementara confidence tinggi menunjukkan bahwa aturan tersebut sering terbukti benar. Misalnya, aturan {roti} → {mentega} dengan lift 3.5 dan confidence 0.8 adalah kandidat kuat untuk strategi cross-selling.

Aplikasi praktis dari aturan ini sangat beragam. Dalam product bundling, kita bisa membuat paket produk yang sering dibeli bersama dengan diskon kecil untuk meningkatkan basket size. Dalam shelf placement, produk yang sering dibeli bersama bisa ditempatkan berdekatan untuk memudahkan pelanggan. Dalam promotional discount, kita bisa memberikan diskon pada satu produk untuk mendorong pembelian produk lain yang berkorelasi kuat.

Namun, kita harus berhati-hati dengan spurious correlations. Lift tinggi tidak otomatis berarti kausalitas. Mungkin {popok} dan {bir} memiliki lift tinggi bukan karena ada hubungan kausal, melainkan karena keduanya dibeli oleh segmen pelanggan yang sama pada waktu yang sama. Interpretasi bisnis tetap membutuhkan domain knowledge dan validasi lebih lanjut.

Keterbatasan Apriori dan Alternatif yang Lebih Scalable

Apriori Algorithm memiliki kelemahan yang mulai terasa pada dataset besar. Algoritma ini melakukan multiple database scans, setiap iterasi memindai seluruh dataset untuk menghitung support. Jumlah kandidat itemset juga bisa tumbuh secara eksponensial pada iterasi awal, meskipun properti pruning membantu menguranginya.

Untuk dataset dengan ribuan produk dan jutaan transaksi, Apriori bisa menjadi sangat lambat. Di sinilah FP-Growth (Frequent Pattern Growth) hadir sebagai alternatif. FP-Growth menggunakan struktur data tree (FP-Tree) yang memampatkan representasi transaksi, sehingga hanya perlu dua kali database scan tanpa perlu menghasilkan kandidat itemset secara eksplisit.

Untungnya, Mlxtend menyediakan implementasi FP-Growth melalui fungsi fpgrowth() yang memiliki API identik dengan apriori(). Cukup ganti satu baris kode untuk beralih dari Apriori ke FP-Growth. Sebagai panduan kasar, gunakan Apriori untuk dataset kecil hingga menengah (ribuan transaksi) dan FP-Growth untuk dataset yang lebih besar. Keduanya menghasilkan output yang sama, yaitu frequent itemsets yang bisa langsung digunakan untuk generate association rules.

Association Rule Mining dengan Apriori Algorithm adalah teknik yang powerful untuk menggali pola tersembunyi dalam data transaksi. Dari memahami metrik support, confidence, dan lift hingga implementasi praktis dengan Python, keterampilan ini sangat relevan untuk berbagai peran di bidang data science dan analitik bisnis. Ingin menguasai data science lebih dalam? Bergabunglah dengan program bootcamp dan kursus data science di Rumah Coding untuk pembelajaran terstruktur dengan studi kasus dunia nyata.