Lewati ke isi

Proyek: Analisis Keranjang Belanja Minimarket

Gambaran singkat

Apa ini? Proyek penutup yang merangkai seluruh alur aturan asosiasi pada data minimarket.

Analogi

Seperti ujian praktik setelah belajar teori: semua langkah dijalankan berurutan.

Mengapa penting? Di dunia nyata, hasil aturan asosiasi harus diterjemahkan menjadi tindakan, misalnya paket belanja dan penataan rak. Proyek ini menunjukkan jalannya.

Yang akan dipelajari, berurutan:

  1. Membersihkan transaksi dan mengodekannya.
  2. Menambang itemset sering dengan FP-Growth.
  3. Membentuk dan menyaring aturan, mengurangi redundansi.
  4. Menguji kestabilan dan menafsirkan hasil untuk bisnis.

Istilah awal:

Istilah Arti sederhana
Bundling Menjual beberapa barang sebagai satu paket
Merchandising Pengaturan barang dan rak di toko
TransactionEncoder Alat mlxtend untuk mengubah transaksi menjadi tabel one-hot

Tujuan proyek

Menerapkan alur aturan asosiasi lengkap: membersihkan transaksi, mengodekan, menambang itemset sering dengan FP-Growth, membentuk dan menyaring aturan, mengurangi redundansi, menguji kestabilan, dan menyiapkan tabel aturan untuk keputusan merchandising.

Masalah dan data

Masalah: menemukan barang yang sering dibeli bersamaan agar tim merchandising dapat menyusun paket (bundling), penempatan rak, dan rekomendasi.

Data: sintetis, 3000 transaksi dari 20 barang minimarket (seed berbeda dari lesson sebelumnya), dengan beberapa pola yang sengaja ditanam dan satu barang sangat populer (kantong_plastik). Hasil tidak mencerminkan perilaku belanja nyata.

Alur kerja

  1. Normalisasi nama barang, hapus duplikat, dan buang keranjang kosong.
  2. TransactionEncoder lalu FP-Growth dengan min_support=0,02.
  3. Bentuk aturan; saring dengan lift ≥ 1,2, confidence ≥ 0,5, dan antecedent ≤ 2 barang.
  4. Kurangi redundansi: satu aturan terbaik per itemset gabungan.
  5. Uji kestabilan: tambang dari paruh pertama, ukur lift pada paruh kedua.
  6. Simpan tabel aturan.

Tidak ada prediksi, pembagian latih/uji klasik, atau penyajian model lewat API di proyek ini: keluaran akhirnya adalah tabel aturan yang ditinjau manusia.

Implementasi langkah demi langkah

Program examples/association/project.py. Konsep tiap langkah sudah dibahas di pelajaran sebelumnya; di sini fokusnya pada penyatuan langkah. Program lengkap ada di akhir bagian ini.

Langkah 1: pembersihan dan pengodean

project.py
# 1. Data dan pembersihan: normalisasi nama, hapus duplikat barang, buang keranjang kosong
raw = make_transactions(n=3000, seed=11)
transactions = [sorted({item.strip().lower() for item in basket}) for basket in raw if basket]
print("jumlah transaksi:", len(transactions), "| rata-rata barang per keranjang: %.2f" % (
    sum(map(len, transactions)) / len(transactions)))

te = TransactionEncoder()
df = pd.DataFrame(te.fit(transactions).transform(transactions), columns=te.columns_)

make_transactions(n=3000, seed=11) membuat 3000 keranjang sintetis (seed berbeda dari lesson sebelumnya). Pembersihan: {item.strip().lower() for item in basket} menormalkan nama dan membuang duplikat; if basket membuang keranjang kosong. TransactionEncoder lalu membuat matriks True/False (penjelasan).

jumlah transaksi: 3000 | rata-rata barang per keranjang: 3.27

Hasil. 3000 transaksi dengan rata-rata 3,27 barang per keranjang.

Langkah 2: penambangan dan penyaringan aturan

project.py
# 2. Penambangan pada data penuh (tanpa target; tidak ada pembagian latih/uji)
itemsets = fpgrowth(df, min_support=0.02, use_colnames=True)
rules = association_rules(itemsets, num_itemsets=len(df), metric="lift", min_threshold=1.2)
rules = rules[(rules["confidence"] >= 0.5) & (rules["antecedents"].apply(len) <= 2)]
print("itemset sering: %d | aturan setelah penyaringan (lift >= 1.2, confidence >= 0.5, antecedent <= 2 barang): %d" % (
    len(itemsets), len(rules)))
Kode Penjelasan
fpgrowth(df, min_support=0.02, ...) Itemset sering pada seluruh data (tidak ada pembagian latih/uji pada tugas ini).
association_rules(..., metric="lift", min_threshold=1.2) Hanya aturan dengan lift ≥ 1,2.
rules["confidence"] >= 0.5 dan rules["antecedents"].apply(len) <= 2 Tambahan saringan: confidence ≥ 0,5 dan antecedent paling banyak dua barang.
itemset sering: 163 | aturan setelah penyaringan (lift >= 1.2, confidence >= 0.5, antecedent <= 2 barang): 71

Hasil. FP-Growth menemukan 163 itemset sering; saringan meninggalkan 71 aturan.

Langkah 3: mengurangi redundansi

Konsep. Satu itemset gabungan dapat menghasilkan banyak aturan yang pada dasarnya sama (misalnya A+B → C dan A → B+C). Kita mempertahankan satu aturan terbaik per itemset gabungan.

project.py
def name(s):
    return " + ".join(sorted(s))


# 3. Kurangi redundansi: pertahankan aturan dengan lift tertinggi untuk tiap itemset gabungan
rules = rules.assign(items=[frozenset(a | c) for a, c in zip(rules["antecedents"], rules["consequents"])])
best = rules.sort_values(["lift", "confidence"], ascending=False).drop_duplicates("items")
best["rule"] = best["antecedents"].apply(name) + "  ->  " + best["consequents"].apply(name)
print("itemset gabungan unik:", len(best))
print("\n" + best.head(8)[["rule", "support", "confidence", "lift"]].round(3).to_string(index=False))
Kode Penjelasan
frozenset(a \| c) Gabungan antecedent a dan consequent c sebagai satu itemset (\| = gabungan himpunan).
rules.assign(items=[...]) Menambahkan kolom items dengan itemset gabungan tiap aturan.
sort_values(["lift", "confidence"], ascending=False).drop_duplicates("items") Mengurutkan dari lift terbesar, lalu membuang baris berikutnya yang itemset gabungannya sudah muncul: tersisa aturan terbaik per itemset.
itemset gabungan unik: 42

                                  rule  support  confidence   lift
       gula + mentega  ->  kopi + roti    0.026       0.743 16.508
mentega + telur  ->  mie_instan + roti    0.022       0.516  8.941
          air_mineral + gula  ->  kopi    0.030       0.856  4.899
    kantong_plastik + sabun  ->  sampo    0.033       0.516  4.731
                      sampo  ->  sabun    0.075       0.685  4.703
                kopi + telur  ->  gula    0.023       0.716  4.678
                 kopi + roti  ->  gula    0.031       0.696  4.551
              gula + mentega  ->  kopi    0.028       0.790  4.526

Interpretasi. 71 aturan dirampingkan menjadi 42 itemset gabungan unik. Pasangan yang jelas dan dapat ditindaklanjuti: sampo → sabun (support 0,075; confidence 0,685; lift 4,70), kopi + roti → gula (lift 4,55), dan air_mineral + gula → kopi (confidence 0,856; lift 4,90). Pola ini cocok untuk uji bundling "kopi + gula", penempatan rak berdekatan, atau rekomendasi.

Hati-hati dengan lift ekstrem

Aturan teratas gula + mentega → kopi + roti memiliki lift 16,5, tetapi aturan ini menggabungkan dua pola yang sebenarnya terpisah, (kopi, gula) dan (roti, mentega), yang kebetulan muncul bersamaan. Karena masing-masing pola cukup langka, peluang bersama yang kecil dibagi dengan hasil kali peluang yang lebih kecil lagi menghasilkan lift raksasa. Informasi yang bermakna ada pada dua pasangan itu, bukan pada aturan empat barang ini. Lift tinggi pada itemset besar sering menunjukkan struktur gabungan, bukan pola baru.

Langkah 4: uji kestabilan

Konsep. Sebagai pengganti validasi, aturan ditambang hanya dari paruh pertama transaksi lalu diperiksa pada paruh kedua (penjelasan).

project.py
# 4. Pemeriksaan kestabilan sebagai pengganti validasi: aturan dari paruh pertama diuji pada paruh kedua
half = len(df) // 2
first, second = df.iloc[:half], df.iloc[half:]
r1 = association_rules(fpgrowth(first, min_support=0.02, use_colnames=True), num_itemsets=len(first),
                       metric="lift", min_threshold=1.2)
r1 = r1[(r1["confidence"] >= 0.5) & (r1["antecedents"].apply(len) <= 2)]
top = r1.sort_values("lift", ascending=False).head(5)


def lift_in(data, ant, con):
    p_a, p_c = data[list(ant)].all(axis=1).mean(), data[list(con)].all(axis=1).mean()
    p_ac = data[list(ant | con)].all(axis=1).mean()
    return p_ac / (p_a * p_c)


print("\nStabilitas 5 aturan teratas paruh 1 -> lift pada paruh 2")
for r in top.itertuples():
    print(f"{name(r.antecedents):<22} -> {name(r.consequents):<10} paruh1 {r.lift:.2f} | paruh2 {lift_in(second, r.antecedents, r.consequents):.2f}")

r1 adalah aturan dari paruh pertama (dengan saringan yang sama); top adalah lima dengan lift tertinggi. lift_in(second, ...) menghitung lift tiap aturan pada paruh kedua. Perulangan mencetak lift paruh 1 dan paruh 2 berdampingan.

Stabilitas 5 aturan teratas paruh 1 -> lift pada paruh 2
gula + mentega         -> kopi + roti paruh1 16.44 | paruh2 16.58
kopi + roti            -> gula + mentega paruh1 16.44 | paruh2 16.58
gula + roti            -> kopi + mentega paruh1 15.87 | paruh2 16.13
kopi + mentega         -> gula + roti paruh1 15.87 | paruh2 16.13
mentega + telur        -> mie_instan + roti paruh1 9.63 | paruh2 8.24

Interpretasi. Aturan teratas paruh pertama bertahan pada paruh kedua (misalnya lift 16,44 menjadi 16,58; 15,87 menjadi 16,13), sedangkan mentega + telur → mie_instan + roti turun dari 9,63 menjadi 8,24, yaitu masih tinggi tetapi lebih berayun. Dengan data sintetis yang pola tanamnya stabil, hasil ini wajar; pada data nyata, musim dan promosi sering menurunkan kestabilan.

Langkah 5: tabel keluaran

project.py
# 5. Simpan tabel aturan (keluaran proyek ini adalah tabel, bukan model prediksi)
out = best[["rule", "support", "confidence", "lift"]].reset_index(drop=True)
print("\ntabel aturan siap disimpan sebagai CSV: %d baris, kolom %s" % (len(out), out.columns.tolist()))
tabel aturan siap disimpan sebagai CSV: 42 baris, kolom ['rule', 'support', 'confidence', 'lift']

Hasil. Tabel 42 baris (aturan, support, confidence, lift) siap disimpan, misalnya dengan out.to_csv("aturan.csv", index=False), untuk ditinjau tim merchandising. Sama seperti hasil lain di bab ini, tabel ini tidak memerlukan "model tersimpan" atau API.

Program lengkap (project.py)
project.py
"""Proyek analisis keranjang belanja minimarket (transaksi SINTETIS)."""
import pandas as pd
from mlxtend.frequent_patterns import association_rules, fpgrowth
from mlxtend.preprocessing import TransactionEncoder

from basket_data import make_transactions

# 1. Data dan pembersihan: normalisasi nama, hapus duplikat barang, buang keranjang kosong
raw = make_transactions(n=3000, seed=11)
transactions = [sorted({item.strip().lower() for item in basket}) for basket in raw if basket]
print("jumlah transaksi:", len(transactions), "| rata-rata barang per keranjang: %.2f" % (
    sum(map(len, transactions)) / len(transactions)))

te = TransactionEncoder()
df = pd.DataFrame(te.fit(transactions).transform(transactions), columns=te.columns_)

# 2. Penambangan pada data penuh (tanpa target; tidak ada pembagian latih/uji)
itemsets = fpgrowth(df, min_support=0.02, use_colnames=True)
rules = association_rules(itemsets, num_itemsets=len(df), metric="lift", min_threshold=1.2)
rules = rules[(rules["confidence"] >= 0.5) & (rules["antecedents"].apply(len) <= 2)]
print("itemset sering: %d | aturan setelah penyaringan (lift >= 1.2, confidence >= 0.5, antecedent <= 2 barang): %d" % (
    len(itemsets), len(rules)))


def name(s):
    return " + ".join(sorted(s))


# 3. Kurangi redundansi: pertahankan aturan dengan lift tertinggi untuk tiap itemset gabungan
rules = rules.assign(items=[frozenset(a | c) for a, c in zip(rules["antecedents"], rules["consequents"])])
best = rules.sort_values(["lift", "confidence"], ascending=False).drop_duplicates("items")
best["rule"] = best["antecedents"].apply(name) + "  ->  " + best["consequents"].apply(name)
print("itemset gabungan unik:", len(best))
print("\n" + best.head(8)[["rule", "support", "confidence", "lift"]].round(3).to_string(index=False))

# 4. Pemeriksaan kestabilan sebagai pengganti validasi: aturan dari paruh pertama diuji pada paruh kedua
half = len(df) // 2
first, second = df.iloc[:half], df.iloc[half:]
r1 = association_rules(fpgrowth(first, min_support=0.02, use_colnames=True), num_itemsets=len(first),
                       metric="lift", min_threshold=1.2)
r1 = r1[(r1["confidence"] >= 0.5) & (r1["antecedents"].apply(len) <= 2)]
top = r1.sort_values("lift", ascending=False).head(5)


def lift_in(data, ant, con):
    p_a, p_c = data[list(ant)].all(axis=1).mean(), data[list(con)].all(axis=1).mean()
    p_ac = data[list(ant | con)].all(axis=1).mean()
    return p_ac / (p_a * p_c)


print("\nStabilitas 5 aturan teratas paruh 1 -> lift pada paruh 2")
for r in top.itertuples():
    print(f"{name(r.antecedents):<22} -> {name(r.consequents):<10} paruh1 {r.lift:.2f} | paruh2 {lift_in(second, r.antecedents, r.consequents):.2f}")

# 5. Simpan tabel aturan (keluaran proyek ini adalah tabel, bukan model prediksi)
out = best[["rule", "support", "confidence", "lift"]].reset_index(drop=True)
print("\ntabel aturan siap disimpan sebagai CSV: %d baris, kolom %s" % (len(out), out.columns.tolist()))

Refleksi

  • Gunakan lift dan support bersama; periksa aturan besar dengan membaca aturan pasangannya.
  • Terapkan penilaian manusia sebelum tindakan; uji tindakan lewat eksperimen kecil, misalnya paket promosi pada beberapa toko.
  • Ulangi analisis berkala dan bandingkan dengan periode sebelumnya.

Latihan

  1. Turunkan min_support menjadi 0,01. Apa yang berubah pada jumlah dan kualitas aturan?
  2. Buat saringan yang menghapus aturan dengan konsekuen kantong_plastik dan lihat dampaknya.
  3. Hitung kestabilan memakai pembagian tiga bagian (sepertiga pertama, tengah, akhir).
  4. Tulis rekomendasi untuk tim merchandising berdasarkan tiga aturan pilihan Anda, beserta alasan dan keterbatasan.

Ringkasan

Proyek ini memperlihatkan alur aturan asosiasi yang benar: pembersihan dan pengodean, penambangan dengan ambang yang disengaja, penyaringan berbasis lift, pengurangan redundansi, uji kestabilan sebagai pengganti validasi, dan keluaran berupa tabel untuk keputusan manusia.

Selesai dengan bab Aturan Asosiasi dan seluruh kurikulum. Kembali ke Peta Belajar untuk meninjau seluruh alur kerja.