Lewati ke isi

Penyaringan Aturan, Ambang Batas, dan Keterbatasan

Gambaran singkat

Apa ini? Cara memilih ambang, menyaring aturan agar yang tersisa berguna, dan mengenali keterbatasan aturan asosiasi.

Analogi

Dari 10.000 aturan, tim pemasaran hanya sanggup membaca 20. Kita perlu penyaring agar yang sampai ke mereka adalah yang paling berguna.

Mengapa penting? Ambang terlalu longgar menghasilkan ribuan aturan tidak berguna; terlalu ketat menghilangkan pola penting. Selain itu, aturan asosiasi menunjukkan keterkaitan, bukan sebab-akibat.

Yang akan dipelajari, berurutan:

  1. Memilih min_support dan min_confidence.
  2. Menyaring dengan lift dan ukuran antecedent.
  3. Menilai kestabilan aturan tanpa pembagian latih/uji klasik.
  4. Mengenali keterbatasan aturan asosiasi.

Istilah awal:

Istilah Arti sederhana
Ambang Batas minimal untuk menyimpan sebuah aturan
Redundan Aturan berlebihan yang artinya hampir sama
Kestabilan Aturan tetap muncul di sampel data berbeda

Tujuan pembelajaran

  • Memilih min_support dan min_confidence serta memahami dampaknya pada jumlah aturan.
  • Menyaring aturan dengan lift, confidence, dan ukuran antecedent.
  • Menilai kestabilan aturan tanpa pembagian latih/uji klasik.
  • Mengenali keterbatasan aturan asosiasi.

Memilih ambang

  • min_support menentukan pola yang cukup sering untuk berguna dan sekaligus mengendalikan ledakan jumlah itemset. Nilainya bergantung pada ukuran data: terlalu tinggi menghilangkan pola penting tetapi langka; terlalu rendah menghasilkan banyak pola kebetulan dan beban komputasi besar.
  • min_confidence menyaring kekuatan aturan, tetapi jangan dipakai sendirian.
  • Lift menyaring aturan yang sekadar mengikuti popularitas barang (misalnya lift ≥ 1,2).
  • Ukuran antecedent: aturan dengan banyak barang di sisi kiri sulit dipakai dan sering redundan.
  • Pilihan akhir sebaiknya mempertimbangkan kegunaan bisnis (berapa aturan yang dapat ditinjau manusia) dan biaya komputasi.

Mengapa tidak ada split latih/uji klasik?

Tidak ada label yang diprediksi, sehingga tidak ada galat prediksi untuk dihitung pada data uji. Alternatifnya adalah uji kestabilan: tambang aturan dari satu bagian transaksi (misalnya paruh pertama menurut waktu) lalu periksa apakah aturan itu masih berlaku, misalnya lift-nya, pada bagian lain. Aturan yang hanya muncul di satu bagian kemungkinan kebetulan atau musiman.

Implementasi langkah demi langkah

Data: 2000 transaksi sintetis (penjelasan). Program examples/association/filtering_thresholds.py; program lengkap ada di akhir bagian ini.

Langkah 1: fungsi mine dan pengaruh ambang

Tujuan. Membungkus "itemset sering → aturan" dalam satu fungsi agar dapat diulang dengan ambang berbeda.

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


def mine(data, min_support, min_confidence):
    its = fpgrowth(data, min_support=min_support, use_colnames=True)
    if len(its) == 0:
        return pd.DataFrame()
    return association_rules(its, num_itemsets=len(data), metric="confidence", min_threshold=min_confidence)


# 1. Jumlah aturan menurut kombinasi ambang
print("min_support  min_confidence=0.3  0.5  0.7")
for ms in [0.01, 0.02, 0.05]:
    counts = [len(mine(df, ms, mc)) for mc in [0.3, 0.5, 0.7]]
    print(f"{ms:<12} {counts[0]:<19} {counts[1]:<4} {counts[2]}")

Fungsi mine(data, min_support, min_confidence) menjalankan FP-Growth lalu association_rules; bila tidak ada itemset (len(its) == 0) ia mengembalikan tabel kosong. Perulangan menghitung jumlah aturan untuk tiap kombinasi min_support (baris) dan min_confidence (kolom): counts adalah tiga angka (satu per min_confidence).

min_support  min_confidence=0.3  0.5  0.7
0.01         568                 319  200
0.02         182                 98   70
0.05         45                  22   15

Interpretasi. Dengan min_confidence=0,3, jumlah aturan 568 (min_support=0,01), 182 (0,02), dan 45 (0,05). Menurunkan min_support menaikkan jumlah aturan dengan cepat; pada 0,01 sudah terlalu banyak untuk ditinjau manual.

Langkah 2: penyaringan bertahap

filtering_thresholds.py
# 2. Penyaringan bertahap pada min_support=0.02, min_confidence=0.3
rules = mine(df, 0.02, 0.3)
step1 = rules[rules["lift"] >= 1.2]
step2 = step1[step1["confidence"] >= 0.5]
print("\naturan awal: %d -> lift >= 1.2: %d -> confidence >= 0.5: %d" % (len(rules), len(step1), len(step2)))
single = step2[(step2["antecedents"].apply(len) == 1) & (step2["consequents"].apply(len) == 1)]
print("dengan satu barang di tiap sisi:", len(single))
Kode Penjelasan
rules[rules["lift"] >= 1.2] Hanya aturan dengan lift ≥ 1,2 (membuang yang sekadar mengikuti popularitas).
step1[step1["confidence"] >= 0.5] Dari sisanya, hanya confidence ≥ 0,5.
step2["antecedents"].apply(len) == 1 Panjang himpunan antecedent sama dengan 1; digabung dengan & untuk consequent: aturan satu barang di tiap sisi.
aturan awal: 182 -> lift >= 1.2: 131 -> confidence >= 0.5: 91
dengan satu barang di tiap sisi: 10

Hasil. 182 aturan awal → 131 setelah lift ≥ 1,2 → 91 setelah confidence ≥ 0,5. Dengan hanya satu barang di tiap sisi tersisa 10 aturan yang ringkas.

Langkah 3: confidence lolos tetapi lift gagal

filtering_thresholds.py
# 3. Aturan yang lolos confidence tetapi gagal lift (barang populer)
popular = rules[(rules["confidence"] >= 0.4) & (rules["lift"] < 1.2)]
print("aturan confidence >= 0.4 tetapi lift < 1.2: %d (konsekuen terbanyak: %s)" % (
    len(popular), popular["consequents"].apply(lambda s: ",".join(sorted(s))).value_counts().head(2).to_dict()))

Saringan: confidence ≥ 0,4 tetapi lift < 1,2. popular["consequents"].apply(lambda s: ",".join(sorted(s))).value_counts() menghitung konsekuen mana yang paling sering muncul di antara aturan itu.

aturan confidence >= 0.4 tetapi lift < 1.2: 42 (konsekuen terbanyak: {'kantong_plastik': 42})

Interpretasi. 42 aturan, seluruhnya berkonsekuen kantong_plastik: barang populer yang muncul di hampir separuh keranjang. Saringan lift menyingkirkannya.

Langkah 4: uji kestabilan sebagai pengganti pembagian latih/uji

Konsep. Tidak ada label untuk diprediksi, sehingga alternatifnya: tambang aturan dari paruh pertama transaksi, lalu periksa apakah aturan itu (misalnya liftnya) masih berlaku pada paruh kedua.

filtering_thresholds.py
# 4. Pengganti pembagian latih/uji: uji kestabilan aturan pada paruh transaksi berikutnya
half = len(df) // 2
first, second = df.iloc[:half], df.iloc[half:]
rules_a = mine(first, 0.02, 0.3)
rules_a = rules_a[(rules_a["lift"] >= 1.2) & (rules_a["confidence"] >= 0.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) if p_a > 0 and p_c > 0 and p_ac > 0 else 0.0


rules_a["lift_paruh2"] = [lift_in(second, a, c) for a, c in zip(rules_a["antecedents"], rules_a["consequents"])]
kept = (rules_a["lift_paruh2"] >= 1.2).mean()
print("\nAturan dari paruh 1: %d | masih lift >= 1.2 pada paruh 2: %.0f%%" % (len(rules_a), 100 * kept))
diff = rules_a["lift"] - rules_a["lift_paruh2"]
print("selisih lift (paruh 1 - paruh 2): median %.3f | terkecil %.2f | terbesar %.2f" % (diff.median(), diff.min(), diff.max()))
rare = rules_a.assign(n=(rules_a["support"] * len(first)).round().astype(int)).nsmallest(1, "support")
print("aturan dengan support terkecil: %d keranjang pada paruh 1" % rare["n"].iloc[0])
Kode Penjelasan
df.iloc[:half], df.iloc[half:] Paruh pertama dan kedua transaksi menurut urutan.
mine(first, 0.02, 0.3) lalu saringan lift dan confidence Aturan hanya ditambang dari paruh pertama.
def lift_in(data, ant, con) Menghitung lift sebuah aturan pada data lain: data[list(ant)].all(axis=1) bernilai True untuk keranjang yang memuat semua barang antecedent; rata-ratanya adalah peluangnya. Lift = \(P(A \cap B)/(P(A)P(B))\).
(rules_a["lift_paruh2"] >= 1.2).mean() Proporsi aturan yang masih berlift ≥ 1,2 pada paruh kedua.
diff = lift paruh 1 - lift paruh 2 Seberapa besar lift bergeser.
Aturan dari paruh 1: 98 | masih lift >= 1.2 pada paruh 2: 99%
selisih lift (paruh 1 - paruh 2): median -0.005 | terkecil -7.96 | terbesar 1.23
aturan dengan support terkecil: 20 keranjang pada paruh 1

Interpretasi. Dari 98 aturan yang lolos saringan pada paruh pertama, 99% masih memiliki lift ≥ 1,2 pada paruh kedua. Median selisih lift hampir nol (-0,005), tetapi rentangnya lebar (-7,96 sampai +1,23): aturan dengan support terkecil (20 keranjang pada paruh 1) berayun besar karena sampel kecil. Aturan yang muncul pada sedikit keranjang tidak boleh dipercaya meski lift-nya tinggi.

Program lengkap (filtering_thresholds.py)
filtering_thresholds.py
import pandas as pd
from mlxtend.frequent_patterns import association_rules, fpgrowth
from mlxtend.preprocessing import TransactionEncoder

from basket_data import make_transactions

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


def mine(data, min_support, min_confidence):
    its = fpgrowth(data, min_support=min_support, use_colnames=True)
    if len(its) == 0:
        return pd.DataFrame()
    return association_rules(its, num_itemsets=len(data), metric="confidence", min_threshold=min_confidence)


# 1. Jumlah aturan menurut kombinasi ambang
print("min_support  min_confidence=0.3  0.5  0.7")
for ms in [0.01, 0.02, 0.05]:
    counts = [len(mine(df, ms, mc)) for mc in [0.3, 0.5, 0.7]]
    print(f"{ms:<12} {counts[0]:<19} {counts[1]:<4} {counts[2]}")

# 2. Penyaringan bertahap pada min_support=0.02, min_confidence=0.3
rules = mine(df, 0.02, 0.3)
step1 = rules[rules["lift"] >= 1.2]
step2 = step1[step1["confidence"] >= 0.5]
print("\naturan awal: %d -> lift >= 1.2: %d -> confidence >= 0.5: %d" % (len(rules), len(step1), len(step2)))
single = step2[(step2["antecedents"].apply(len) == 1) & (step2["consequents"].apply(len) == 1)]
print("dengan satu barang di tiap sisi:", len(single))

# 3. Aturan yang lolos confidence tetapi gagal lift (barang populer)
popular = rules[(rules["confidence"] >= 0.4) & (rules["lift"] < 1.2)]
print("aturan confidence >= 0.4 tetapi lift < 1.2: %d (konsekuen terbanyak: %s)" % (
    len(popular), popular["consequents"].apply(lambda s: ",".join(sorted(s))).value_counts().head(2).to_dict()))

# 4. Pengganti pembagian latih/uji: uji kestabilan aturan pada paruh transaksi berikutnya
half = len(df) // 2
first, second = df.iloc[:half], df.iloc[half:]
rules_a = mine(first, 0.02, 0.3)
rules_a = rules_a[(rules_a["lift"] >= 1.2) & (rules_a["confidence"] >= 0.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) if p_a > 0 and p_c > 0 and p_ac > 0 else 0.0


rules_a["lift_paruh2"] = [lift_in(second, a, c) for a, c in zip(rules_a["antecedents"], rules_a["consequents"])]
kept = (rules_a["lift_paruh2"] >= 1.2).mean()
print("\nAturan dari paruh 1: %d | masih lift >= 1.2 pada paruh 2: %.0f%%" % (len(rules_a), 100 * kept))
diff = rules_a["lift"] - rules_a["lift_paruh2"]
print("selisih lift (paruh 1 - paruh 2): median %.3f | terkecil %.2f | terbesar %.2f" % (diff.median(), diff.min(), diff.max()))
rare = rules_a.assign(n=(rules_a["support"] * len(first)).round().astype(int)).nsmallest(1, "support")
print("aturan dengan support terkecil: %d keranjang pada paruh 1" % rare["n"].iloc[0])

Keterbatasan

Keterbatasan Penjelasan
Asosiasi bukan sebab-akibat Pola belanja dapat dipengaruhi musim, promosi, atau penempatan rak
Banyak aturan, sedikit yang berguna Perlu penyaringan dan penilaian manusia
Aturan sangat langka tidak stabil Support kecil membuat lift berayun
Barang populer mendistorsi confidence Gunakan lift dan ukuran lain
Mengabaikan kuantitas, harga, dan urutan waktu Aturan klasik hanya melihat ada atau tidaknya barang
Hasil bergantung ambang Laporkan ambang yang dipakai

Kesalahan umum

Hindari

  • Menetapkan ambang agar menghasilkan "cukup banyak aturan" tanpa alasan.
  • Menafsirkan aturan langka berlift tinggi sebagai temuan.
  • Mengabaikan aturan redundan (A+B→C dan A→C yang hampir sama).
  • Mengira lolos saringan statistik berarti layak ditindaklanjuti.

Latihan

  1. Tambahkan saringan leverage ≥ 0,02 dan lihat berapa aturan tersisa.
  2. Ubah pembagian menjadi 30% pertama dan 70% sisanya. Apakah kestabilan berubah?
  3. Susun daftar kriteria "aturan layak ditindaklanjuti" untuk tim merchandising.

Ringkasan

Pilih ambang dengan mempertimbangkan ukuran data, lift, dan kegunaan; saring dengan lift dan ukuran antecedent; uji kestabilan pada bagian transaksi lain sebagai pengganti split latih/uji; dan ingat bahwa aturan asosiasi adalah pola, bukan sebab-akibat.

Berikutnya: Proyek Analisis Keranjang Belanja.