Lewati ke isi

Data Transaksi dan Pengodean

Gambaran singkat

Apa ini? Pelajaran pembuka aturan asosiasi: memahami data transaksi (keranjang belanja) dan mengubahnya menjadi tabel yang bisa dianalisis.

Analogi

Kasir minimarket mencatat isi setiap keranjang. Dari ribuan struk, kita ingin tahu barang apa yang sering dibeli bersamaan, misalnya roti dengan mentega.

Mengapa penting? Komputer tidak bisa membaca daftar belanja mentah. Data harus dibersihkan lalu diubah menjadi tabel ya/tidak (one-hot) agar bisa dihitung.

Yang akan dipelajari, berurutan:

  1. Arti transaksi, item, dan itemset.
  2. Membersihkan data transaksi.
  3. Mengubah transaksi menjadi matriks one-hot.
  4. Menghitung support sederhana dan ringkasan keranjang.

Istilah awal:

Istilah Arti sederhana
Transaksi Satu keranjang belanja
Item / itemset Satu barang / kumpulan barang
One-hot Tabel berisi ya (1) atau tidak (0) untuk tiap barang
Support Persentase transaksi yang memuat suatu itemset

Tujuan pembelajaran

  • Memahami data transaksi dan analisis keranjang belanja (market basket analysis).
  • Membersihkan data transaksi dan mengubahnya menjadi matriks one-hot.
  • Menghitung support sederhana dari data dan membaca ringkasan keranjang.

Konsep

Analisis keranjang belanja mencari barang yang sering dibeli bersamaan. Satuannya adalah transaksi (satu keranjang atau satu struk) yang berisi himpunan barang (item); sekumpulan barang disebut itemset.

Istilah Arti
Transaksi Satu keranjang: himpunan barang yang dibeli bersamaan
Itemset Himpunan satu atau lebih barang, misalnya
Support Proporsi transaksi yang memuat sebuah itemset
\[ \text{support}(X) = \frac{\text{jumlah transaksi yang memuat } X}{\text{jumlah seluruh transaksi}} \]

Berbeda dengan bab lain, tidak ada target yang diprediksi dan tidak ada pembagian latih/uji wajib. Tujuannya menemukan pola; cara menilai kualitas dibahas di lesson aturan dan lesson penyaringan.

Persiapan data

  1. Satu baris per barang per transaksi pada data mentah (format panjang), lalu dikelompokkan menjadi daftar barang per transaksi.
  2. Normalisasi nama barang: huruf kecil, hapus spasi berlebih, samakan ejaan.
  3. Hapus duplikat barang dalam satu transaksi: aturan asosiasi klasik hanya peduli ada atau tidaknya barang, bukan jumlahnya.
  4. Buang transaksi kosong, dan pertimbangkan transaksi berisi satu barang (tidak menyumbang pasangan, tetapi memengaruhi support).
  5. Tentukan tingkat barang: "roti tawar" dan "roti gandum" dipisah atau digabung menjadi "roti"? Tingkat yang terlalu rinci membuat support sangat kecil.
  6. Pengodean ke matriks transaksi × barang bernilai benar/salah (TransactionEncoder).

Implementasi langkah demi langkah

Bagian 1 memakai 5 transaksi kecil agar dapat dihitung tangan; bagian 3–4 memakai 2000 transaksi sintetis dari basket_data.py (20 barang, dibangkitkan dengan seed tetap, dengan beberapa pola yang sengaja ditanam). Karena sintetis, pola yang ditemukan tidak mencerminkan perilaku belanja nyata. Program examples/association/transactions_encoding.py; program lengkap ada di akhir bagian ini.

Kode pembangkit data (basket_data.py)
basket_data.py
"""Transaksi belanja SINTETIS (dibangkitkan dengan seed tetap) untuk latihan aturan asosiasi.

Pola yang ditanam: roti+mentega(+selai), mie_instan+telur, kopi+gula, popok+susu, sabun+sampo.
Barang 'kantong_plastik' sengaja sangat populer agar terlihat bahaya membaca confidence tanpa lift.
"""
import numpy as np

# barang -> peluang dasar muncul pada sebuah transaksi (di luar pola yang ditanam)
BASE = {
    "roti": 0.06, "mentega": 0.03, "selai": 0.04, "susu": 0.12, "telur": 0.12, "mie_instan": 0.14,
    "kopi": 0.07, "gula": 0.05, "teh": 0.10, "beras": 0.12, "minyak": 0.10, "sabun": 0.08,
    "sampo": 0.04, "popok": 0.03, "pisang": 0.10, "apel": 0.07, "kantong_plastik": 0.45,
    "tisu": 0.10, "deterjen": 0.07, "air_mineral": 0.25,
}
PATTERNS = [  # (peluang pola muncul, barang pada pola)
    (0.16, ["roti", "mentega"]),
    (0.07, ["roti", "mentega", "selai"]),
    (0.10, ["mie_instan", "telur"]),
    (0.12, ["kopi", "gula"]),
    (0.06, ["popok", "susu"]),
    (0.07, ["sabun", "sampo"]),
]


def make_transactions(n=2000, seed=42):
    rng = np.random.default_rng(seed)
    transactions = []
    for _ in range(n):
        basket = {item for item, p in BASE.items() if rng.random() < p}
        for p, items in PATTERNS:
            if rng.random() < p:
                basket.update(items)
        if not basket:  # transaksi kosong tidak ada
            basket.add("air_mineral")
        transactions.append(sorted(basket))
    return transactions

Langkah 1: contoh kecil dan matriks one-hot

Konsep. Algoritma asosiasi bekerja pada tabel transaksi × barang bernilai benar/salah: sel True berarti barang itu ada di keranjang itu. TransactionEncoder membuatnya dari daftar-daftar barang.

transactions_encoding.py
# 1. Contoh kecil yang dapat dihitung tangan: 5 transaksi
tiny = [["roti", "mentega"], ["roti", "susu"], ["roti", "mentega", "telur"], ["susu", "telur"], ["roti", "mentega"]]
te = TransactionEncoder()
onehot = pd.DataFrame(te.fit(tiny).transform(tiny), columns=te.columns_)
print(onehot.astype(int).to_string())
print("\nsupport {roti}          = %d/5 = %.2f" % (onehot["roti"].sum(), onehot["roti"].mean()))
print("support {roti, mentega} = %d/5 = %.2f" % ((onehot["roti"] & onehot["mentega"]).sum(), (onehot["roti"] & onehot["mentega"]).mean()))
Kode Penjelasan
tiny = [["roti", "mentega"], ...] Daftar transaksi; tiap transaksi adalah list barang.
TransactionEncoder() Pengubah dari daftar barang ke matriks (mirip encoder scikit-learn).
te.fit(tiny).transform(tiny) fit mempelajari semua barang unik; transform menghasilkan array True/False. Nama kolom ada di te.columns_.
onehot.astype(int) Menampilkan True/False sebagai 1/0 agar mudah dibaca.
onehot["roti"].sum(), .mean() Jumlah dan proporsi keranjang yang memuat roti = support.
(onehot["roti"] & onehot["mentega"]) & memilih keranjang yang memuat kedua barang.
   mentega  roti  susu  telur
0        1     1     0      0
1        0     1     1      0
2        1     1     0      1
3        0     0     1      1
4        1     1     0      0

support {roti}          = 4/5 = 0.80
support {roti, mentega} = 3/5 = 0.60

Hasil. Roti muncul pada 4 dari 5 keranjang (support 0,80); roti dan mentega bersama pada 3 dari 5 (0,60). Perhitungan ini persis yang dilakukan algoritma pada skala besar.

Langkah 2: pembersihan transaksi

transactions_encoding.py
# 2. Pembersihan: duplikat barang dalam satu transaksi dan huruf besar/kecil
raw = [["Roti", "roti ", "MENTEGA"], ["susu", "susu", "telur"]]
clean = [sorted({item.strip().lower() for item in basket}) for basket in raw]
print("\nsebelum:", raw, "\nsesudah:", clean)

{item.strip().lower() for item in basket} adalah set comprehension: strip() membuang spasi di tepi, lower() mengecilkan huruf, dan himpunan (set) otomatis membuang duplikat. sorted(...) mengubahnya kembali menjadi daftar berurutan.

sebelum: [['Roti', 'roti ', 'MENTEGA'], ['susu', 'susu', 'telur']] 
sesudah: [['mentega', 'roti'], ['susu', 'telur']]

Hasil. "Roti", "roti ", dan "MENTEGA" menjadi roti dan mentega, dan duplikat dalam satu keranjang hilang.

Langkah 3: ringkasan data transaksi

transactions_encoding.py
# 3. Data transaksi sintetis (2000 keranjang) dan ringkasannya
transactions = make_transactions()
sizes = pd.Series([len(t) for t in transactions])
print("\njumlah transaksi: %d | rata-rata barang per keranjang: %.2f | ukuran keranjang min/maks: %d/%d" % (
    len(transactions), sizes.mean(), sizes.min(), sizes.max()))
print("distribusi ukuran keranjang:", sizes.value_counts().sort_index().to_dict())
freq = Counter(i for t in transactions for i in t)
top = pd.Series(freq).sort_values(ascending=False)
print("barang terpopuler (jumlah keranjang):", top.head(5).to_dict())
print("barang paling jarang:", top.tail(3).to_dict())
Kode Penjelasan
sizes = pd.Series([len(t) for t in transactions]) Jumlah barang tiap keranjang.
sizes.value_counts().sort_index().to_dict() Distribusi ukuran keranjang: berapa keranjang berisi 1, 2, 3, ... barang.
Counter(i for t in transactions for i in t) Menghitung berapa kali tiap barang muncul (Counter dari modul collections); generator dengan dua for meratakan daftar bersarang.
top.head(5), top.tail(3) Lima barang paling populer dan tiga paling jarang.
jumlah transaksi: 2000 | rata-rata barang per keranjang: 3.31 | ukuran keranjang min/maks: 1/11
distribusi ukuran keranjang: {1: 377, 2: 395, 3: 395, 4: 332, 5: 242, 6: 145, 7: 62, 8: 40, 9: 10, 10: 1, 11: 1}
barang terpopuler (jumlah keranjang): {'kantong_plastik': 895, 'air_mineral': 650, 'roti': 527, 'mentega': 492, 'mie_instan': 437}
barang paling jarang: {'popok': 152, 'deterjen': 140, 'apel': 128}

Interpretasi. 2000 transaksi dengan rata-rata 3,31 barang per keranjang (1 sampai 11); 377 keranjang hanya berisi satu barang. Barang terpopuler: kantong_plastik (895 keranjang, 44,8%), air_mineral (650), roti (527); paling jarang: popok (152), deterjen (140), apel (128).

Langkah 4: matriks one-hot data besar

transactions_encoding.py
# 4. Pengodean one-hot (matriks transaksi x barang, boolean)
te = TransactionEncoder()
df = pd.DataFrame(te.fit(transactions).transform(transactions), columns=te.columns_)
print("\nukuran matriks: %s | proporsi sel bernilai True: %.3f" % (df.shape, df.to_numpy().mean()))

df.to_numpy().mean() merata-ratakan seluruh sel True/False (dihitung 1/0), yaitu proporsi sel bernilai benar.

ukuran matriks: (2000, 20) | proporsi sel bernilai True: 0.166

Interpretasi. Ukuran matriks 2000 × 20 dan hanya 16,6% selnya bernilai benar. Matriks ini jarang (sparse); pada ribuan barang, ukurannya menjadi masalah memori sehingga representasi jarang atau penyaringan barang langka diperlukan.

Program lengkap (transactions_encoding.py)
transactions_encoding.py
from collections import Counter

import numpy as np
import pandas as pd
from mlxtend.preprocessing import TransactionEncoder

from basket_data import make_transactions

# 1. Contoh kecil yang dapat dihitung tangan: 5 transaksi
tiny = [["roti", "mentega"], ["roti", "susu"], ["roti", "mentega", "telur"], ["susu", "telur"], ["roti", "mentega"]]
te = TransactionEncoder()
onehot = pd.DataFrame(te.fit(tiny).transform(tiny), columns=te.columns_)
print(onehot.astype(int).to_string())
print("\nsupport {roti}          = %d/5 = %.2f" % (onehot["roti"].sum(), onehot["roti"].mean()))
print("support {roti, mentega} = %d/5 = %.2f" % ((onehot["roti"] & onehot["mentega"]).sum(), (onehot["roti"] & onehot["mentega"]).mean()))

# 2. Pembersihan: duplikat barang dalam satu transaksi dan huruf besar/kecil
raw = [["Roti", "roti ", "MENTEGA"], ["susu", "susu", "telur"]]
clean = [sorted({item.strip().lower() for item in basket}) for basket in raw]
print("\nsebelum:", raw, "\nsesudah:", clean)

# 3. Data transaksi sintetis (2000 keranjang) dan ringkasannya
transactions = make_transactions()
sizes = pd.Series([len(t) for t in transactions])
print("\njumlah transaksi: %d | rata-rata barang per keranjang: %.2f | ukuran keranjang min/maks: %d/%d" % (
    len(transactions), sizes.mean(), sizes.min(), sizes.max()))
print("distribusi ukuran keranjang:", sizes.value_counts().sort_index().to_dict())
freq = Counter(i for t in transactions for i in t)
top = pd.Series(freq).sort_values(ascending=False)
print("barang terpopuler (jumlah keranjang):", top.head(5).to_dict())
print("barang paling jarang:", top.tail(3).to_dict())

# 4. Pengodean one-hot (matriks transaksi x barang, boolean)
te = TransactionEncoder()
df = pd.DataFrame(te.fit(transactions).transform(transactions), columns=te.columns_)
print("\nukuran matriks: %s | proporsi sel bernilai True: %.3f" % (df.shape, df.to_numpy().mean()))

Kesalahan umum

Hindari

  • Memasukkan kuantitas atau harga seolah barang berbeda (aturan klasik hanya melihat ada/tidaknya barang).
  • Membiarkan barang berduplikat atau ejaan berbeda.
  • Tingkat barang yang terlalu rinci sehingga tidak ada itemset yang sering.
  • Memasukkan barang yang selalu ada (kantong, biaya kirim) tanpa menyadari efeknya pada aturan.

Latihan

  1. Hitung manual support {susu, telur} pada contoh kecil, lalu cek dengan kode.
  2. Buat transaksi dari tabel format panjang (transaction_id, item) dengan groupby.
  3. Hapus kantong_plastik dari data sintetis dan hitung ulang rata-rata barang per keranjang.

Ringkasan

Data transaksi berupa himpunan barang per keranjang. Bersihkan nama dan duplikat, tentukan tingkat barang, lalu ubah menjadi matriks one-hot. Support adalah proporsi transaksi yang memuat suatu itemset.

Berikutnya: Itemset Sering dan Apriori.