ASSOCIATION RULE
DATAMINING
sumber :
modul praktikum Universitas Ahmad Dahlan Yogyakarta
A.
Teori
Pendukung
Association
Rule adalah teknik data mining yang berguna untuk menemukan suatu korelasi atau
pola yang terpenting/menarik dari sekumpulan data besar (Margaret, 2003). Motivasi
awal Association Rule berasal dari keinginan untuk menganalisa data transaksi supermarket
ditinjau dari perilaku pelanggan dalam membeli produk. Association Rule
menjelaskan seberapa sering suatu produk dibeli secara bersamaan. Sebagai
contoh: seorang pelanggan membeli sabun maka seberapa mungkin juga ia membeli
pasta gigi (Kuswardani dkk, 2011)
Dengan pengetahuan tersebut,
pemilik pasar swalayan orang dapat mengatur penempatan barangnya atau merancang
kampanye pemasaran memakai kupon diskon untuk
kombinasi barang tertentu. Penting tidaknya suatu aturan asosiatis dapat
diketahui dengan dua parameter, support yaitu persentase kombinasi item
tersebut. Dan confidence yaitu kuatnya hubungan antar item dalam aturan
asosiatif. Penting tidaknya suatu aturan assosiatif dapat diketahui dengan dua
parameter, support yaitu persentase kombinasi item tsb. dalam database
dan confidence yaitu kuatnya hubungan antar item dalam aturan
assosiatif (Ernawati,2007)
A.
Langkah
Praktikum :
1.
Jika akan dilakukan
analisis data mining menggunakan data alumni untuk mengetahui hubungan antara fasilitas
memadai, sdm berpengaruh, kerja sesuai jurusan dan kurikulum sesuai dengan
dunia kerja. Maka lakukanlah analisis data alumni untuk kemudian
dilakukan proses Asosiasi/Apriori data.
2.
Buka data set siswa
dengan nama Data Alumni.xlxs
3.
Lakukan proses
clustering data menggunakan python.
4.
Melakukan Import
Library yang akan digunakan untuk clustering:
5.
Kemudian import
library untuk menyelesaikan algoritma apriori
|
def
subsets(arr):
""" Returns non empty
subsets of arr"""
return chain(*[combinations(arr, i + 1)
for i, a in enumerate(arr)])
def
returnItemsWithMinSupport(itemSet, transactionList, minSupport, freqSet):
"""calculates the
support for items in the itemSet and returns a subset
of the itemSet each of whose elements
satisfies the minimum support"""
_itemSet = set()
localSet = defaultdict(int)
for item in itemSet:
for transaction in transactionList:
if
item.issubset(transaction):
freqSet[item]
+= 1
localSet[item] += 1
for item, count in localSet.items():
support =
float(count)/len(transactionList)
if support >= minSupport:
_itemSet.add(item)
return _itemSet
def
joinSet(itemSet, length):
"""Join a set with
itself and returns the n-element itemsets"""
return set([i.union(j) for i in
itemSet for j in itemSet if len(i.union(j)) == length])
def
getItemSetTransactionList(data_iterator):
transactionList = list()
itemSet = set()
for record in data_iterator:
transaction = frozenset(record)
transactionList.append(transaction)
for item in transaction:
itemSet.add(frozenset([item])) # Generate 1-itemSets
return itemSet, transactionList
def
runApriori(data_iter, minSupport, minConfidence):
"""
run the apriori algorithm. data_iter is a
record iterator
Return both:
- items (tuple, support)
- rules ((pretuple, posttuple),
confidence)
"""
itemSet, transactionList =
getItemSetTransactionList(data_iter)
freqSet = defaultdict(int)
largeSet = dict()
# Global dictionary which stores
(key=n-itemSets,value=support)
# which satisfy minSupport
assocRules = dict()
# Dictionary which stores Association
Rules
oneCSet =
returnItemsWithMinSupport(itemSet,
transactionList,
minSupport,
freqSet)
currentLSet = oneCSet
k = 2
while(currentLSet != set([])):
largeSet[k-1] = currentLSet
currentLSet = joinSet(currentLSet, k)
currentCSet =
returnItemsWithMinSupport(currentLSet,
transactionList,
minSupport,
freqSet)
currentLSet = currentCSet
k = k + 1
def getSupport(item):
"""local function
which Returns the support of an item"""
return float(freqSet[item])/len(transactionList)
toRetItems = []
for key, value in largeSet.items():
toRetItems.extend([(tuple(item),
getSupport(item))
for item in
value])
toRetRules = []
for key, value in largeSet.items()[1:]:
for item in value:
_subsets = map(frozenset, [x for
x in subsets(item)])
for element in _subsets:
remain =
item.difference(element)
if len(remain) > 0:
confidence =
getSupport(item)/getSupport(element)
if confidence >=
minConfidence:
toRetRules.append(((tuple(element), tuple(remain)),
confidence))
return toRetItems, toRetRules
def
printResults(items, rules):
"""prints the generated
itemsets sorted by support and the confidence rules sorted by
confidence"""
dSupport = {}
for item, support in sorted(items,
key=lambda (item, support): support):
dSupport[item] = support
print("item: %s , %.3f" %
(str(item), support))
for rule, confidence in sorted(rules,
key=lambda (rule, confidence): confidence):
pre, post = rule
tempRule=()
tempRule+=pre
tempRule+=post
supportAimplikasiB =
getSupportAimplikasiB(tempRule, dSupport)
lift =
supportAimplikasiB/(dSupport[pre]*dSupport[post])
print("Rule: %s ==> %s :
[confidence is %.3f, lift is %.3f]" % (str(pre), str(post), confidence,
lift))
def
getSupportAimplikasiB(A, B):
rule = list(A)
dict_support = B
result = 0
for index_dict_support in dict_support:
list_index_dict_support =
list(index_dict_support)
check = []
for data_index in
list_index_dict_support:
if data_index in rule and len(list_index_dict_support) >=
len(rule):
check.append(True)
else:
check.append(False)
if(reduce(mul, check, 1)==True):
# print(list_index_dict_support)
#
print(dict_support[index_dict_support])
result =
dict_support[index_dict_support]
return result
def
dataFromFile(fname):
"""Function which
reads from the file and yields a generator"""
file_iter = open(fname, 'rU')
for line in file_iter:
line =
line.strip().rstrip(',') # Remove trailing
comma
record =
frozenset(line.split(','))
yield record
|
6.
Load data excel
yang akan dilakukan proses asosiasi:
Output:
7.
Templating data
yang dibutuhkan kedalam format tabel.
8.
Lakukan konversi
data kedalam format yang siap untuk
dilakukan asosiasi:
9.
Panggil fungsi runApriori dengan parameter masukan variable list_data hasil
dari konversi sebelumnya, minSupport = 0.1, minConfidence = 0.2. dapat dilihat
sebagai berikut.
No comments:
Post a Comment