4.3.1.1 Implementasi Proses Transfer Data
Proses transfer data pada OLAP dilakukan secara manual dapat dilakukan dengan cara mengeksekusi file Automatisasi_data.bat. Isi
perintah file Automatisasi_data.bat dapat dilihat pada tabel 4.10
Tabel 4.10 Tabel kode perintah file Automatisasi_data.bat
C: cd C:\Kettle3.1
Kitchen.bat -
file=C:\Users\Esy\Documents\transformasi\automatisasi.kjb
Proses eksekusi transformasi data dapat dilihat pada gambar 4.35.
Gambar 4.35 Proses Transfer Data
4.3.2 Gudang Data untuk penerapan Algoritma Apriori
Algoritma apriori akan diterapkan pada gudang data untuk melakukan perhitungan asosiasi mengambil atribut hari, atribut lintasan, dan atribut
pendapatan. Setelah itu dilakukan scanning terhadap database dengan melakukan query sql. Query tersebut dapat dilihat pada tabel 4.11
Tabel 4.11 Query SQL untuk scanning data hari, lintasan, dan pendapatan
select distincthari,
lintasan, pendapatan
from ms_operasional_c;
Berdasarkan query tersebut akan tampil data hari, lintasan, dan pendapatan seperti pada Gambar 4.36. Data kapal diproses untuk mencari
kandidat itemset yang masuk sesuai dengan minimum support dan minimum confidence yang diinputkan. Hasil dari perhitungan asosiasi
dapat dilihat pada gambar 4.37
Gambar 4.36 hasil query data
Berdasarkan hasil query pada gambar 4.36, terlihat bahwa masing- masing atribut memiliki data yang berbeda. Dalam proses perhitungan
dengan algoritma, data hasil query disimpan dalam sebuah arraylist. ArrayList
tersebut akan digunakan untuk proses pencarian Candidate itemset.
public void getData { ResultSet rs = null;
try { Statement st = connector.createStatement;
String query = select distincthari, lintasan, pendapatan from ms_operasional_c;
rs = st.executeQueryquery; if rs = null {
while rs.next { test2 t = new test2;
t.setHarirs.getString1; t.setLintasanrs.getString2;
t.setPendapatanrs.getString3; data.addt;
}
for int i = 0; i data.size; i++ { System.out.printlnData: + data.geti;
} crazy.adddata.clone;
jumlahrecord = data.size; System.out.printlnjumlah data: +
jumlahrecord; }
} catch Exception e { System.out.printlne;
} }
Setelah data tersimpan arraylist selanjutnya akan dilakukan pencarian candidate, perhitungan count dan support dari setiap candidate. Dilakukan
perulangan while untuk mendapatkan data distinct yang telah tersimpan di array sebelumnya sebagai candidate 1-itemset yang selanjutnya
dimasukkan ke dalam arraylist data1. Berdasarkan panjang arraylist data1 akan dilakukan proses perhitungan count dan support dari
candidate 1-itemset. Hasil perhitungan data akan disimpan di arraylist baru
yaitu temp2.
public void findCandidate1Itemsets { count array itemset
int i = 1; int x = 0;
int cur = 0; int jmldata = 0;
int vv = 0; String[][] tes;
while data.size x { if data1.isEmpty {
data1.adddata.getx; } else {
if data1.containsdata.getx { } else {
data1.adddata.getx; }
} x++;
} System.out.printlnProses penjumlahan;
tes = new String[data1.size][2]; while data1.size cur {
x = 0; jmldata = 0;
while data.size x { if data.getx.equalsdata1.getcur {
jmldata++; }
x++; }
tes[cur][0] = data1.getcur.toString; tes[cur][1] = + jmldata;
temp1.addjmldata; cur++;
} for int j = 0; j tes.length; j++ {
System.out.printlntes[j][0] + + tes[j][1]; }
count support x = 0;
while temp1.size x { hitung =
twoDecPlacesDouble.parseDoubleString.valueOfDouble.parseDouble temp1.getx.toString jumlahrecord;
temp2.addhitung; x++;
} System.out.printlnsupport + temp2;
}
Untuk mendapatkan frequent 1-itemset dilakukan perulangan while sepanjang jumlah candidate 1-itemset dengan nilai membandingkan nilai
support candidate 1-itemset dengan nilai minimum support yang
dimasukkan pengguna. Jika support nya lebih besar dari minimum support maka candidate 1-itemset tersebut menjadi frequent 1-itemset. Frequent 1-
itemset dan supportnya akan dimasukkan ke dalam konstruktor Itemset
string, double yang selanjutnya akan dimasukkan ke dalam arraylist temp3.
private LargeItemset findFrequent_1_itemset{ String min1 = 10;
double min11 = Integer.parseIntmin1; System.out.printlnmin11: +min11;
minsup =Double min11 100; System.out.printlnminsup: +minsup;
int x = 0; whiletemp2.size x{
double sup1 = twoDecPlacesDouble.parseDoubleString.valueOfDouble.parseDouble
temp2.getx.toString; if sup1 = minsup{
String item = data1.getx.toString; System.out.printlnitem: +item;
temp3.addnew Itemsetitem,sup1; ak.additem;
} x++ ;
} System.out.printlnada +temp3;
int jumfreq1 = temp3.size; System.out.println\nFrequent 1-itemset\t : +jumfreq1;
Itemset[] itemss = new Itemset[temp3.size]; for int i = 0; i temp3.size; i++ {
itemss[i] = Itemset temp3.geti; System.out.printlntheItemss: +itemss[i];
} System.out.printlnFrequent 1 -itemset: +itemss.length;
return new LargeItemsetitemss, 1; }
Untuk pencarian frequent k-itemset diawali dengan memasukan semua frequent 1- itemset
ke dalam arraylist ls dengan memanggil method putLargeItemset yang ada di kelas Ls
public void putLargeItemset l { ls.addl.getK - 1, l;
}
Selanjutnya dilakukan proses pencarian candidate k-itemset dengan memanggil method aprioriGen di kelas LargeItemset yang bertipe
Candidate dimana di dalam method ini dilakukan proses pencarian subset dan join antar frequent itemset dengan memanggil method joinItemset
dan getSubsetint,int yang ada di kelas Itemset.
method aprioriGen untuk mencari kombinasi candidate k-itemset public Candidate aprioriGen {
ArrayList cItems = new ArrayList; for int i = 0; i items.length; i++ {
for int j = i + 1; j items.length; j++ { if items[i].similarToitems[j] {
Itemset c = items[i].joinitems[j]; System.out.printlnc: +c;
if hasInfrequentSubsetc { cItems.addc;
System.out.printlncItems; +cItems; System.out.printlncItemslength:
+cItems.size; }
} }
} if cItems.size == 0 { return new Candidatenull, k + 1;
} else { Itemset[] theCItems = new Itemset[cItems.size];
for int i = 0; i cItems.size; i++ { theCItems[i] = Itemset cItems.geti;
}return new CandidatetheCItems, k + 1; }
} method similarTo untuk membandingkan apakah itemset pertama
sama dengan itemset kedua, jika tidak sama maka kedua itemset tersebut akan dijoinkan untuk menghasilkan candidate itemset yang
baru public boolean similarToItemset item {
if elements.length == 1 { return elements[0].equalsitem.elements[0];
} for int i = 0; i elements.length - 1; i++ {
if elements[i].equalsitem.elements[i] { return false;
} }
return
elements[elements.length -
1].equalsitem.elements[elements.length - 1]; }
method join untuk menggabungkan kedua itemset jika keduanya merupakan itemset yang berbeda
public Itemset joinItemset item { String[] joinedElements = new String[elements.length + 1];
for int i = 0; i elements.length; i++ { joinedElements[i] = new Stringelements[i];
} joinedElements[elements.length]
= new
Stringitem.elements[elements.length - 1]; return new ItemsetjoinedElements, 0d;
} method hasInfrequentSubset untuk meninjau apakah itemset yang
telah dijoinkan merupakan subset dari frequent itemset sebelumnya public boolean hasInfrequentSubsetItemset c {
for int i = 0; i k; i++ { ArrayList cSubSet = c.getSubSeti + 1;
System.out.printlncSubset+k+ :+cSubSet; for int j = 0; j cSubSet.size; j++ {
boolean flag = false; for int l = 0; l items.length; l++ {
System.out.printlnitemseleng: +items.length;
System.out.printlnitemsssa +l+:
+items[l]; if
items[l].getElements.containsAllArrayList cSubSet.getj { flag = true;
break; }}
if flag { return true;
} }} return false;
} method getSubset membuat kombinasi subset dari itemset yang
telah dijoinkan public ArrayList getSubSetint k {
return getSubSetk, elements.length; }
private ArrayList getSubSetint k, int size { ArrayList subSet = new ArrayList;
if k == 1 { for int i = 0; i size; i++ {
ArrayList item = new ArrayList1; item.addelements[i];
subSet.additem; }
return subSet; } else {
for int i = size - 1; i = k - 1; i-- { ArrayList subSubSet = getSubSetk - 1, i;
for int j = 0; j subSubSet.size; j++ { ArrayList item = ArrayList subSubSet.getj;
item.addelements[i]; }
subSet.addAllsubSubSet; }
return subSet; }
}
Selanjutnya dilakukan proses perhitungan count dan support dari candidate k-itemset
yang telah ditemukan dengan melakukan perulangan for, guna membaca data dari list data dan diakhiri dengan proses prunning
untuk menghasilkan frequent k –itemset dengan memanggil method
getLdouble yang ada di kelas Candidate.
pencarian count dan support dari kombinasi candidate k-itemset forint i =0;i items.length;i++{
int count=0; forIterator
iterator =
data.iterator; iterator.hasNext;{
ArrayList elements
= ArrayList
iterator.next;
ifelements.containsAllitems[i].getElements{ count++;
} } items[i].setSupportdoublecount jumlahbaris;
} method getL untuk prunning candidate k-itemset guna mendapatkan
frequent k-itemset public LargeItemset getLdouble minimumSupport {
ArrayList itemArrayList = new ArrayList; for int i = 0; i items.length; i++ {
System.out.printlnitem[i] +i+: +items[i]; if items[i].getSupport = minimumSupport {
itemArrayList.additems[i].clone; } }
if itemArrayList.size == 0 { return new LargeItemsetnull, k;
} Itemset[] itemArray = new Itemset[itemArrayList.size];
for int i = 0; i itemArrayList.size; i++ { itemArray[i] = Itemset itemArrayList.geti;
System.out.printlnitemArray+itemArray[i]; }
return new LargeItemsetitemArray, k; }
Pencarian subset dari semua Frequent k-itemset dilakukan perulangan for sebanyak tingkat frequent k-itemset k guna mendapatkan
frequent k-itemset tiap tingkat. Dari frequent k-itemset tersebut akan dicari
subset nya dengan membandingkan subset yang didapat dengan semua
frequent itemset yang telah didapat. Jika frequent itemset tersebut
mengandung subset yang dibandingkan maka frequent itemset tersebut akan digunakan untuk pencarian aturan asosiasi.
mendapatkan semua subset dari semua frequent k-itemset yang telah dihasilkan
foraaa =0; aaa ada.size; aaa++{ Itemset s = Itemset ada.getaaa;
cari subset dan kombinasi aturan forint b=0; b ls.size; b++{
ArrayList isi = new ArrayList; isi.adds.getElements;
coba = s.getSubSetb+1; forint bb =0; bb coba.size; bb++{
boolean flag = false; forint bbb =0; bbb itemlarge.length;bbb++{
ifitemlarge[bbb].getElements.containsAllArrayListcoba.getbb {
flag = true; break;
} }
Setelah itu akan ditentukan aturan asosiasi yang kuat dengan penentuan frequent itemset
yang akan menjadi anteseden dan konsekuen, menentukan support
untuk keduanya lalu menghitung nilai confidence dari aturan yang terbentuk. Aturan yang memiliki nilai confidence lebih besar atau sama
dengan nilai minimum confidence yang dimasukan pengguna akan menjadi aturan asosiasi yang kuat
4.4 Implementasi Antar Muka Pengguna OLAP
Hasil implementasi antar muka pengguna untuk OLAP yang sudah dirancang pada bab sebelumnya dapat dilihat sebagai berikut:
4.4.1 Halaman Login
Kategori