Basket Market
Pendahuluan
Pernah berbelanja ke supermarket atau swalayan? pernah memperhatikan layout sebuah app e commerce? Pernah melihat bagaimana beberapa perusahaan dan pebisnis menjual beberapa jenis barang berbeda dalam satu paket/ bundling?
Jika iya, kalian sedang menyaksikan salah satu bentuk penerapan dari hasil Market Basket Analysis. Mode analisa Market Basket adalah tentang mempelajari concsumption behavior pembeli dengan cara membuat asosiasi antar barang. Intinya : Jika pelanggan membeli produk A, kemungkinan dia akan ikut membeli produk B adalah sebesar…
Analisa ini berguna untuk meningkatkan penjualan dan mengefisiensikan inventori.
Di awalan, kita akan menunjukkan penerapan algoritma ‘apriori’ ini tanpa banyak menjelaskan terlebih dahulu.
# Load library dan data
library(arules)## Warning: package 'arules' was built under R version 4.1.2## Loading required package: Matrix##
## Attaching package: 'arules'## The following objects are masked from 'package:base':
##
## abbreviate, writetransaction_data <- read.delim(file = "https://storage.googleapis.com/dqlab-dataset/data_transaksi.txt") # read.delim untuk file txt
transaction_dataIni adalah data transaksi dari 23 item dengan kode transaksi masing-masing.
Pertama, kita ingin tahu apa class dari data transaksi di atas (tujuannya akan kita tahu nanti)
class(transaction_data)## [1] "data.frame"Oke, data di atas, sesuai dugaan adalah data frame. Lalu apa?
Selanjutnya kita ubah dataframe transaction_data menjadi tipe class ‘transaction’. Bagaimana caranya? untuk menunjukkan prinsip konversi ini, kita akan mulai dengan cara yang salah.
Pada dasarnya untuk konversi data ke class transaction, adalah dengan menuliskan :
transaction_data <- as(transaction_data, "transactions")trans_data <- as(transaction_data,"transactions")## Warning: Column(s) 1, 2 not logical or factor. Applying default discretization
## (see '? discretizeDF').class(transaction_data)## [1] "data.frame"inspect(trans_data)## items transactionID
## [1] {Kode.Transaksi=#01, Item=Teh Celup} 1
## [2] {Kode.Transaksi=#01, Item=Sirup} 2
## [3] {Kode.Transaksi=#01, Item=Pet Food} 3
## [4] {Kode.Transaksi=#02, Item=Teh Celup} 4
## [5] {Kode.Transaksi=#02, Item=Gula} 5
## [6] {Kode.Transaksi=#03, Item=Sirup} 6
## [7] {Kode.Transaksi=#03, Item=Pet Food} 7
## [8] {Kode.Transaksi=#04, Item=Teh Celup} 8
## [9] {Kode.Transaksi=#04, Item=Sirup} 9
## [10] {Kode.Transaksi=#05, Item=Teh Celup} 10
## [11] {Kode.Transaksi=#05, Item=Sirup} 11
## [12] {Kode.Transaksi=#05, Item=Gula} 12
## [13] {Kode.Transaksi=#06, Item=Teh Celup} 13
## [14] {Kode.Transaksi=#06, Item=Pet Food} 14
## [15] {Kode.Transaksi=#07, Item=Teh Celup} 15
## [16] {Kode.Transaksi=#07, Item=Sirup} 16
## [17] {Kode.Transaksi=#07, Item=Pet Food} 17
## [18] {Kode.Transaksi=#08, Item=Teh Celup} 18
## [19] {Kode.Transaksi=#09, Item=Teh Celup} 19
## [20] {Kode.Transaksi=#09, Item=Gula} 20
## [21] {Kode.Transaksi=#10, Item=Sirup} 21
## [22] {Kode.Transaksi=#10, Item=Pet Food} 22
## [23] {Kode.Transaksi=#10, Item=Gula} 23Apakah di atas adalah hasil penyusunan yang kita inginkan?
Tentu saja bukan.
Data di atas berantakan berantakan, dan redundan pada kolom transactionID denagan kode transaksi. Terlebih, bahkan kita tidak paham apa yang bisa dicari dari data di atas.
Dari sini, kita belajar bahwa untuk mengubah data ke class transaction tidak semudah itu. Kita harus mengubah data dari bentuk data frame ke bentuk yang lebih sesuai untuk transaction class, yaitu :
- list
- binary matrix
Dengan list, kita bisa membuat objek yang berisi array yang berisi item. Sederhananya, kita akan menjadikan nomor-nomor transaksi sebagai objek list dan di setiap objeknya akan berisi array yang memiliki value berupa nama-nama barang yang dibeli pada transaksi tersebut.
Dengan binary matrix, kita akan memiliki item-item yang tersusun menjadi header kolom, dengan masing-masing observasi (baris) adalah transaksi-transaksinya.
Bingung?
Kita akan ilustrasikan langsung.
# Kita buat objek untuk data transaksi yang baru (untuk mempertahankan bentuk data transaksi yang asli)
trans2_data <- transaction_data
# Dari data frame ini, kita convert seluruh datanya menjadi factor
trans2_data$Kode.Transaksi <- as.factor(trans2_data$Kode.Transaksi)
trans2_data$Item <- as.factor(trans2_data$Item)
# cek dulu
str(trans2_data)## 'data.frame': 23 obs. of 2 variables:
## $ Kode.Transaksi: Factor w/ 10 levels "#01","#02","#03",..: 1 1 1 2 2 3 3 4 4 5 ...
## $ Item : Factor w/ 4 levels "Gula","Pet Food",..: 4 3 2 4 1 3 2 4 3 4 ...Setelah mengubahnya menjadi factor, sekarang kita baru bisa melakukan split terhadap dataframe tersebut berdasar kode transaksinya.
# split() adalah fungsi untuk memecah vector berdasarkan vector lain dan menghasilkan list
# parameter split(vector target, function/vector pemecah)
# Karena kita ingin memecah item berdasar kode transaksi, maka split(Item,Kode.Transaksi)
trans_transdata <- split(trans2_data$Item, trans2_data$Kode.Transaksi)
trans_transdata## $`#01`
## [1] Teh Celup Sirup Pet Food
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#02`
## [1] Teh Celup Gula
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#03`
## [1] Sirup Pet Food
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#04`
## [1] Teh Celup Sirup
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#05`
## [1] Teh Celup Sirup Gula
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#06`
## [1] Teh Celup Pet Food
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#07`
## [1] Teh Celup Sirup Pet Food
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#08`
## [1] Teh Celup
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#09`
## [1] Teh Celup Gula
## Levels: Gula Pet Food Sirup Teh Celup
##
## $`#10`
## [1] Sirup Pet Food Gula
## Levels: Gula Pet Food Sirup Teh CelupSetelah memecah dan membuat list baru berisi item berdasar kode transaksi, sekarang kita bisa konversi data ini menjadi data class transaction.
basket1 <- as(trans_transdata, "transactions")
inspect(basket1)## items transactionID
## [1] {Pet Food, Sirup, Teh Celup} #01
## [2] {Gula, Teh Celup} #02
## [3] {Pet Food, Sirup} #03
## [4] {Sirup, Teh Celup} #04
## [5] {Gula, Sirup, Teh Celup} #05
## [6] {Pet Food, Teh Celup} #06
## [7] {Pet Food, Sirup, Teh Celup} #07
## [8] {Teh Celup} #08
## [9] {Gula, Teh Celup} #09
## [10] {Gula, Pet Food, Sirup} #10Di atas adalah cara untuk membuat data transaction class dari data frame melalui list.
Kelemahan dari metode ini adalah, saat kita berhadapan dataset yang berjumlah puluhan ribu, list menjadi sangat lambat untuk diproses. Oleh karena itu saat berhadapan dengan data besar, ada baiknya kita membiasakan diri untuk menggunakan metode membangun transaction class melalui metode binary matrix.
# Sejujurnya akan lebih mudah bila kita memiliki akses data dengan SQL. Tapi kita akan coba dulu dengan menggunakan fungsi-fungsi dplyr
# load dulu tidyverse
library(tidyverse)## Warning: package 'tidyverse' was built under R version 4.1.2## -- Attaching packages --------------------------------------- tidyverse 1.3.1 --## v ggplot2 3.3.5 v purrr 0.3.4
## v tibble 3.1.4 v dplyr 1.0.7
## v tidyr 1.1.4 v stringr 1.4.0
## v readr 2.0.2 v forcats 0.5.1## Warning: package 'tidyr' was built under R version 4.1.2## Warning: package 'dplyr' was built under R version 4.1.2## -- Conflicts ------------------------------------------ tidyverse_conflicts() --
## x tidyr::expand() masks Matrix::expand()
## x dplyr::filter() masks stats::filter()
## x dplyr::lag() masks stats::lag()
## x tidyr::pack() masks Matrix::pack()
## x dplyr::recode() masks arules::recode()
## x tidyr::unpack() masks Matrix::unpack()# Sebaiknya kita menyusun dulu data item berdasar nomor transaksinya
# kita membuat pivot dengan grouping pada Kode.Transaksi, dan sub-group pada Item, lalu kita buat kolom baru untuk menghitung jumlah per item per transaksi
trans3_data <- transaction_data %>%
group_by(Kode.Transaksi,Item) %>%
mutate(jumlah = n()) %>%
pivot_wider(names_from = Item, values_from = jumlah, values_fill = NA)
trans3_data# Setelah mendapat matrix yang diinginkan, kita harus membuang dulu Kode.Transaksi. Kenapa? karena di sini, Kode.Transaksi berupa chr, lagipula, kode transaksi sudah tidak berguna dikarenkan setip baris sudah menjadi observasi yang unik
trans3_matrix <- trans3_data[,-1]
trans3_matrix# Setelah itu, kita lanjut dengan mengubah value matrix tiap kolom menjadi nilai logika.
# Caranya, gunakan apply(data,1 or 2 (1 for row-based, 2 for column-based), function)
trans3_matrix <- apply(trans3_matrix,2,as.logical)
trans3_matrix## Teh Celup Sirup Pet Food Gula
## [1,] TRUE TRUE TRUE NA
## [2,] TRUE NA NA TRUE
## [3,] NA TRUE TRUE NA
## [4,] TRUE TRUE NA NA
## [5,] TRUE TRUE NA TRUE
## [6,] TRUE NA TRUE NA
## [7,] TRUE TRUE TRUE NA
## [8,] TRUE NA NA NA
## [9,] TRUE NA NA TRUE
## [10,] NA TRUE TRUE TRUE# Jangan lupa untuk mengubah seluruh nilai NA menjadi FALSE
trans3_matrix[(is.na(trans3_matrix))] <- FALSE
# Nah, dalam bentuk seperti ini, baru kita bisa membuat transaction class
basket2 <- as(trans3_matrix, "transactions")
inspect(basket2)## items
## [1] {Teh Celup, Sirup, Pet Food}
## [2] {Teh Celup, Gula}
## [3] {Sirup, Pet Food}
## [4] {Teh Celup, Sirup}
## [5] {Teh Celup, Sirup, Gula}
## [6] {Teh Celup, Pet Food}
## [7] {Teh Celup, Sirup, Pet Food}
## [8] {Teh Celup}
## [9] {Teh Celup, Gula}
## [10] {Sirup, Pet Food, Gula}Selesai.
Sekarang, kita beralih ke pertanyaan berikutnya : Kenapa kita perlu mengubah data kita menjadi bentuk seperti ini?
Jawabannya sederhana. Karena algoritma apriori dalam package arules hanya bisa bekerja dalam bentuk transaction class.
Setelah data ini selesai, kita bisa langsung menerapkan algoritma apriori dalam bentuk fungsi apriori()
# Kita bisa gunakan data manapun, dari basket1 (list) atau basket2(matrix)
mba <- apriori(basket2, parameter = list(supp = 0.1, confidence = 0.5))## Apriori
##
## Parameter specification:
## confidence minval smax arem aval originalSupport maxtime support minlen
## 0.5 0.1 1 none FALSE TRUE 5 0.1 1
## maxlen target ext
## 10 rules TRUE
##
## Algorithmic control:
## filter tree heap memopt load sort verbose
## 0.1 TRUE TRUE FALSE TRUE 2 TRUE
##
## Absolute minimum support count: 1
##
## set item appearances ...[0 item(s)] done [0.00s].
## set transactions ...[4 item(s), 10 transaction(s)] done [0.00s].
## sorting and recoding items ... [4 item(s)] done [0.00s].
## creating transaction tree ... done [0.00s].
## checking subsets of size 1 2 3 done [0.00s].
## writing ... [16 rule(s)] done [0.00s].
## creating S4 object ... done [0.00s].inspect(mba)## lhs rhs support confidence coverage lift
## [1] {} => {Pet Food} 0.5 0.5000000 1.0 1.0000000
## [2] {} => {Sirup} 0.6 0.6000000 1.0 1.0000000
## [3] {} => {Teh Celup} 0.8 0.8000000 1.0 1.0000000
## [4] {Gula} => {Sirup} 0.2 0.5000000 0.4 0.8333333
## [5] {Gula} => {Teh Celup} 0.3 0.7500000 0.4 0.9375000
## [6] {Pet Food} => {Sirup} 0.4 0.8000000 0.5 1.3333333
## [7] {Sirup} => {Pet Food} 0.4 0.6666667 0.6 1.3333333
## [8] {Pet Food} => {Teh Celup} 0.3 0.6000000 0.5 0.7500000
## [9] {Sirup} => {Teh Celup} 0.4 0.6666667 0.6 0.8333333
## [10] {Teh Celup} => {Sirup} 0.4 0.5000000 0.8 0.8333333
## [11] {Pet Food, Gula} => {Sirup} 0.1 1.0000000 0.1 1.6666667
## [12] {Sirup, Gula} => {Pet Food} 0.1 0.5000000 0.2 1.0000000
## [13] {Sirup, Gula} => {Teh Celup} 0.1 0.5000000 0.2 0.6250000
## [14] {Sirup, Pet Food} => {Teh Celup} 0.2 0.5000000 0.4 0.6250000
## [15] {Teh Celup, Pet Food} => {Sirup} 0.2 0.6666667 0.3 1.1111111
## [16] {Teh Celup, Sirup} => {Pet Food} 0.2 0.5000000 0.4 1.0000000
## count
## [1] 5
## [2] 6
## [3] 8
## [4] 2
## [5] 3
## [6] 4
## [7] 4
## [8] 3
## [9] 4
## [10] 4
## [11] 1
## [12] 1
## [13] 1
## [14] 2
## [15] 2
## [16] 2Memahami algoritma Apriori
Ide dari algortima apriori adalah untuk mencari dan menghitung berapa banyak kombinasi item yang muncul dari seluruh transaksi. Jadi, misalkan ada sampel 100 transaksi, dari 100 tersebut, ada 50 transaksi yang muncul sebagai kombinasi. Item A muncul dalam kombinasi sebanyak 12 kali, dan muncul 35 kali ditransaksikan sendirian. Sedangkan item B, dia muncul 40 kali bersama item C, 5 kali bersama item A, hanya muncul 2 kali sendirian. Dalam algorimat apriori, nilai asosiasi item B jauh lebih besar daripada item A, meskipun dia jauh lebih banyak muncul. Hal ini karena algoritma apriori, memperhitungkan kombinasi.
Untuk lebih jelasnya, kita kembali pada data di atas.
inspect(apriori(basket2, parameter = list(target = 'frequent itemsets')))## Apriori
##
## Parameter specification:
## confidence minval smax arem aval originalSupport maxtime support minlen
## NA 0.1 1 none FALSE TRUE 5 0.1 1
## maxlen target ext
## 10 frequent itemsets TRUE
##
## Algorithmic control:
## filter tree heap memopt load sort verbose
## 0.1 TRUE TRUE FALSE TRUE 2 TRUE
##
## Absolute minimum support count: 1
##
## set item appearances ...[0 item(s)] done [0.00s].
## set transactions ...[4 item(s), 10 transaction(s)] done [0.00s].
## sorting and recoding items ... [4 item(s)] done [0.00s].
## creating transaction tree ... done [0.00s].
## checking subsets of size 1 2 3 done [0.00s].
## sorting transactions ... done [0.00s].
## writing ... [13 set(s)] done [0.00s].
## creating S4 object ... done [0.00s].
## items support count
## [1] {Gula} 0.4 4
## [2] {Pet Food} 0.5 5
## [3] {Sirup} 0.6 6
## [4] {Teh Celup} 0.8 8
## [5] {Pet Food, Gula} 0.1 1
## [6] {Sirup, Gula} 0.2 2
## [7] {Teh Celup, Gula} 0.3 3
## [8] {Sirup, Pet Food} 0.4 4
## [9] {Teh Celup, Pet Food} 0.3 3
## [10] {Teh Celup, Sirup} 0.4 4
## [11] {Sirup, Pet Food, Gula} 0.1 1
## [12] {Teh Celup, Sirup, Gula} 0.1 1
## [13] {Teh Celup, Sirup, Pet Food} 0.2 2Dari 10 transaksi di data, apriori (jika tidak di set parameter ‘minlen’) menunjukkan seluruh jumlah transaksi, dimulai dari jumlah transaksi yang melibatkan per item, hingga kombinasi-kombinasi yang terjadi.
Support adalah nilai yang menunjukkan rasio jumlah transaksi item dibandingkan seluruh transaksi. 0.4 pada ‘Gula’ artinya, ‘gula’ muncul 4x dari 10x transaksi. Lalu kombinasi ‘teh celup, gula’ bernilai support 0.3 artinya kombinasi itu muncul 3x dari 10x transaksi.
Apa guna parameter itu? gunanya untuk memasang syarat hasil yang ditampulkan. Jika kita setting support = 0.3, maka R hanya akan menunjukkan product atau kombinasi yang nilai supportnya minimal 0.3. minlen, menunjukkan berapa batas minimal kombinasi yang harus ditunjukkan.
Memahami output apriori algoritma
Item, Itemset, dan Rule
Item –> Produk tunggal yang terdapat dalam satu transaksi Itemset –> Kombinasi satu atau lebih item yang terdapat dalam satu transaksi (berada dalam {}) Rule –> Pernyataan hubungan antar itemset. Pernyataannya sebagai berikut : “Jika membeli itemset A, maka akan membeli itemset B”
Tambahan : lhs —> Left-hand side adalah sisi di mana itemset menjadi prediktor rhs —> right-hand side adalah sisi di mana itemset yang diprediksi akan dibeli dengan adanya itemset di lhs
Jika kita ingin menlihat daftar item unik dari data, maka cukup ketikkan :
dataset@itemInfo*Jika kita ingin melihat daftar kode transaksi, ketikkan :
dataset@itemsetInfoKita juga bisa membentuk matrix dengan
dataset@data Kita juga bisa melihat barapa kali sebuah item muncul di keseluruhan transaksi
itemFrequency(dataset) # Jika ingin melihat angka riil, tambahkan type (dataset@data, type = "absolute")Anggaplah kita ingin mengubah kembali data dari bentuk transaksi ke dataframe.
# load data
transaksi <- read.transactions(file = "https://storage.googleapis.com/dqlab-dataset/data_transaksi.txt", format = "single",
sep = "\t", cols= c(1,2), skip = 1)
# Pada parameter format, 'single' berarti data per item per transaksi dipisahkan di tiap baris, pilihan lainnya adalah 'basket' yang menyajikan satu transaksi dalam tiap baris
# Kita hitung frequency item dalam seluruh transaksi
data_item <- itemFrequency(transaksi, type = "absolut")
# Sorting data
data_item <- sort(data_item, decreasing = TRUE)
# Mengambil 3 item terbanyak
data_item <- data_item[1:3]
# Konversikan data_item menjadi dataframe dengan kolom nama_produk dan jumlah
data_item <- data.frame("Nama Produk" = names(data_item), "Jumlah" = data_item,
row.names = NULL)
data_itemGrafik Item Frequency
Sebelumnya, kita sudah membuat dan menggambarkan distribusi item dalam keseluruhan transaksi menggunakan matrix, sekarang kita juga bisa menggunakan grafik; yaitu dengan fungsi itemFrequencyPlot().
itemFrequencyPlot(transaksi, type = "absolut")
Kembali pada hasil model apriori
inspect(mba)## lhs rhs support confidence coverage lift
## [1] {} => {Pet Food} 0.5 0.5000000 1.0 1.0000000
## [2] {} => {Sirup} 0.6 0.6000000 1.0 1.0000000
## [3] {} => {Teh Celup} 0.8 0.8000000 1.0 1.0000000
## [4] {Gula} => {Sirup} 0.2 0.5000000 0.4 0.8333333
## [5] {Gula} => {Teh Celup} 0.3 0.7500000 0.4 0.9375000
## [6] {Pet Food} => {Sirup} 0.4 0.8000000 0.5 1.3333333
## [7] {Sirup} => {Pet Food} 0.4 0.6666667 0.6 1.3333333
## [8] {Pet Food} => {Teh Celup} 0.3 0.6000000 0.5 0.7500000
## [9] {Sirup} => {Teh Celup} 0.4 0.6666667 0.6 0.8333333
## [10] {Teh Celup} => {Sirup} 0.4 0.5000000 0.8 0.8333333
## [11] {Pet Food, Gula} => {Sirup} 0.1 1.0000000 0.1 1.6666667
## [12] {Sirup, Gula} => {Pet Food} 0.1 0.5000000 0.2 1.0000000
## [13] {Sirup, Gula} => {Teh Celup} 0.1 0.5000000 0.2 0.6250000
## [14] {Sirup, Pet Food} => {Teh Celup} 0.2 0.5000000 0.4 0.6250000
## [15] {Teh Celup, Pet Food} => {Sirup} 0.2 0.6666667 0.3 1.1111111
## [16] {Teh Celup, Sirup} => {Pet Food} 0.2 0.5000000 0.4 1.0000000
## count
## [1] 5
## [2] 6
## [3] 8
## [4] 2
## [5] 3
## [6] 4
## [7] 4
## [8] 3
## [9] 4
## [10] 4
## [11] 1
## [12] 1
## [13] 1
## [14] 2
## [15] 2
## [16] 2Seperti yang kita lihat, terdapat banyak list item dan itemset dari apriori. Ada kalanya, kita ingin fokus pada satu item yang menarik minat kita; misal, kita ingin tahu posisi item “Sirup” dalam aturan asosiasi. Apa yang membuatnya bisa terjual lebih banyak. Artinya, kita ingin melihat posisi “Sirup” di rhs memiliki asosiasi dengan produk apa di lhs.
inspect(subset(mba, rhs %in% "Sirup"))## lhs rhs support confidence coverage lift
## [1] {} => {Sirup} 0.6 0.6000000 1.0 1.0000000
## [2] {Gula} => {Sirup} 0.2 0.5000000 0.4 0.8333333
## [3] {Pet Food} => {Sirup} 0.4 0.8000000 0.5 1.3333333
## [4] {Teh Celup} => {Sirup} 0.4 0.5000000 0.8 0.8333333
## [5] {Pet Food, Gula} => {Sirup} 0.1 1.0000000 0.1 1.6666667
## [6] {Teh Celup, Pet Food} => {Sirup} 0.2 0.6666667 0.3 1.1111111
## count
## [1] 6
## [2] 2
## [3] 4
## [4] 4
## [5] 1
## [6] 2Dari data di atas, diketahui bahwa Sirup memiliki asosiasi yang kuat dengan Pet Food.
Dari mana kita tahu? dengan cara melihat 3 matrix, yaitu ‘support’ ‘confidence’, dan ‘lift’ Apa itu? * support -> rasio antara total kombinasi item dengan total transaksi * Confidence -> rasio nilai support terhadap rasio transaksi item lhs dengan total transaksi * Lift -> rasio nilai support terhadap rasio transaksi lhs dikali rasio transaksi rhs
Logikanya seperti ini : Support menunjukkan berapa kali kombinasi itemset tersebut ditransaksikan. Semakin tinggi nilai support menunjukkan kombinasi barang ini memang kuat.
Tapi efek ini kemudian dilemahkan dengan dibagi oleh rasio transaksi kedua item itu sendiri2. Confidence menunjukkan berapa porsi transaksi kombinasi itu terjadi jika dibandingkan dengan transaksi item di lhs; jika transaksi sirup-gula ada 5/10, tapi ternyata transaksi sirup sendiri sebesar 8/10, artinya ada 3 transaksi di mana gula tidak berkaitan dengan sirup. Untuk lift, kita membandingkan rasio transaksi kombinasi item, dengan berapa kali item sirup dan gula terjadi (baik sendiri, kombinasi berdua, atau kombinasi dengan item lain)
Karena itulah, semakin tinggi nilai ketiga metrik tersebut, membuktikan asosiasi kombinasi item yang semakin kuat.
Plot untuk apriori
Kita bisa menggunakan plot untuk mempermudah pemahaman soal hasil apriori
library(arulesViz)## Warning: package 'arulesViz' was built under R version 4.1.2plot(mba, method = "graph")