Pendekatan Level Algoritma

BAB II LANDASAN TEORI

2.2 Tinjauan Pustaka

2.2.5 Pendekatan Level Algoritma

Boosting telah menunjukkan dapat meningkatkan kinerja pengklasifikasi

dalam banyak situasi, termasuk ketika data tidak seimbang (Seiffert, Khoshgoftaar, Hulse, & Napolitano, 2008, p. 445). Boosting adalah metode umum untuk meningkatkan kinerja algoritma belajar apapun. Secara teori, boosting dapat digunakan untuk mengurangi kesalahan algoritma belajar "lemah" secara signifikan.

AdaBoost adalah kependekan dari Adaptive Boosting (Afza, Farid, & Rahman, 2011, p. 105) (Harrington, 2012, p. 132), merupakan algoritma machine

learning yang dirumuskan oleh Yoav Freund and Robert Schapire. Algoritma

AdaBoost adalah algoritma yang berusaha membangun pengklasifikasi kuat dengan mengombinasikan sejumlah pengklasifikasi sederhana atau lemah secara linier. Algoritma klasifikasi kuat menggunakan teknik seperti ANN (Artificial

Neural Network), SVM (Support Vector Machines), dan lain-lain, sedangkan

algoritma klasifikasi lemah menggunakan teknik seperti Decision Trees, Bayesian

Networks, Random Forests, dan lain-lain (Korada, Kumar, & Deekshitulu, 2012,

p. 64). Algoritma AdaBoost ini menggunakan prinsip dari pohon keputusan (decision tree), pohon keputusan yang digunakan dapat berupa satu tingkat/cabang keputusan (decision stump) atau beberapa tingkat (dapat mencapai tiga tingkat).

Persamaan AdaBoost adalah:

55 Di mana:

ℎ_𝑡(𝑥) : Pengklasifikasi dasar atau lemah ∝_𝑡 : Tingkat pembelajaran (learning rate)

F(x) : Hasil, berupa pengklasifikasi kuat atau akhir

Kelebihan dari algorithma AdaBoost:

a. Mampu mengurangi nilai bias maupun perbedaan pada pengklasifikasi lemah (weak classifier)

b. Memiliki kemampuan generalisasi yang baik

c. Keluaran (output) AdaBoost mengonversi ke logaritma dengan rasio terdekat

d. AdaBoost dapat dilihat sebagai pemilih fitur dengan strategi berprinsip (minimalisasi dari batas atas error)

e. AdaBoost dekat dengan pembuatan keputusan linier

Algoritma AdaBoost (Zhou & Yu, AdaBoost, 2009, p. 130):

Masukan:

Dataset D = {(x1,y1), (x2,y2), ..., (xm,ym)}; Algoritma pembelajaran lemah (Weak Learner) L; Sebuah integer T yang menspesifikasi banyaknya iterasi.

Proses:

Inisialisasi berat distribusi: 𝐷₁(𝑖) = ¹

𝑚 untuk semua 𝑖 = 1, … , 𝑚 for t=1, ... , T:

Melatih pembelajar dasar/lemah ht dari D menggunakan distribusi Dt

ht = L(D,Dt)

Mengkalkulasi kesalahan dari ht: 𝜀_𝑡 = 𝑃𝑟_{𝑥~𝐷𝑡,𝑦}𝐼[ℎ_𝑡(𝑥_𝑖) ≠ 𝑦_𝑖] if εt > 0.5 then break

Menetapkan berat dari ht: ∝_𝑡= ¹

2ln (^1−𝜖𝑡

56 𝐷_𝑡+1(𝑖) =^{𝐷𝑡(𝑖)}

𝑍_𝑡 ^{x {}

𝑒𝑥𝑝(−∝_𝑡) 𝑖𝑓 ℎ_𝑡(𝑥_𝑖) = 𝑦_𝑖 𝑒𝑥𝑝(∝_𝑡) 𝑖𝑓 ℎ_𝑡(𝑖) ≠ 𝑦_𝑖

Meng-update distribusi, di mana Zt adalah faktor normalisasi yang mengaktifkan Dt+1 menjadi distribusi:

𝐷_𝑡(𝑖)𝑒𝑥𝑝(−∝_𝑡 𝑦_𝑖ℎ_𝑡(𝑥_𝑖)) 𝑍_𝑡 end Keluaran: Pengklasifikasi akhir/kuat: 𝐻(𝑥) = 𝑠𝑖𝑔𝑛(∑𝑇 ∝_𝑡 ℎ_𝑡(𝑥) 𝑡=1 ) (2. 19)

Kesalahan diukur dengan memperhatikan distribusi Dt di mana algoritma pembelajar lemah dilatih. Dalam prakteknya, algoritma pembelajar lemah mungkin merupakan suatu algoritma yang dapat menggunakan bobot Dt pada sampel pelatihan. Atau, bila hal ini tidak memungkinan, bagian dari sampel pelatihan dapat di-resampling menurut Dt, dan hasil dari resampling yang tidak berbobot (unweighted) dapat digunakan untuk melatih algoritma pembelajar yang lemah.

AdaBoost menghasilkan urutan hipotesis dan menggabungkannya dengan bobot, yang dapat dianggap sebagai kombinasi bobot tambahan dalam bentuk persamaan 2.18.

𝐻(𝑥) = ∑𝑇 ∝_𝑡 ℎ_𝑡(𝑥)

𝑡=1 (2. 20)

Dari pandangan ini, AdaBoost sebenarnya memecahkan dua masalah, yaitu bagaimana untuk menghasilkan hipotesis ht dan bagaimana menentukan bobot yang tepat αt.

Dalam rangka untuk memiliki proses pengurangan kesalahan yang sangat efisien, maka dicoba meminimalkan kerugian eksponensial.

57

Kerugian dari setiap contoh dapat terurai, yang disebut kerugian titik bijaksana (pointwise), seperti persamaan 2.20.

𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻+∝ ℎ | 𝑥) = 𝐸_𝑦[𝑒^{−𝑦(𝐻(𝑥)+𝛼ℎ(𝑥)}|𝑥] (2. 22)

Karena y dan h(x) harus +1 atau -1, maka harapan dapat diperluas sebagai:

𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻+∝ ℎ | 𝑥) = 𝑒−𝑦𝐻(𝑥)(𝑒^−∝𝑃(𝑦 = ℎ(𝑥)|𝑥) + 𝑒^∝𝑃(𝑦 ≠ ℎ(𝑥)|𝑥)) (2. 23)

Misalkan telah dihasilkan h, dan dengan berat ∝ yang meminimalkan kerugian dapat ditemukan ketika turunan dari kerugian sama dengan nol, yaitu:

𝜗𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻+∝ℎ | 𝑥)

𝛿𝛼 = 𝑒−𝑦𝐻(𝑥)(𝑒−∝𝑃(𝑦 = ℎ(𝑥)|𝑥) + 𝑒∝𝑃(𝑦 ≠ ℎ(𝑥)|𝑥)) (2. 24) = 0

Maka solusinya adalah:

∝ =¹

2ln^{𝑃(𝑦 = ℎ(𝑥)|𝑥)}

𝑃(𝑦 ≠ ℎ(𝑥)|𝑥) = ¹

2ln^{1−𝑃(𝑦 ≠ ℎ(𝑥)|𝑥)}

𝑃(𝑦 ≠ ℎ(𝑥)|𝑥) (2. 25)

Dengan mengambil harapan atas x, yaitu, memecahkan ^{𝜗𝑙𝑜𝑠𝑠𝑒𝑥𝑝(𝐻+∝ℎ | 𝑥)}

𝛿𝛼 ,

dan menunjukkan 𝜖 = 𝐸_𝑥~𝐷[𝑦 ≠ ℎ(𝑥)], maka didapatkan persamaan 2.24.

∝ =¹

2ln^1−𝜖

𝜖 (2. 26)

yang merupakan cara untuk menentukan αt di AdaBoost.

Selanjutnya mempertimbangkan bagaimana untuk menghasilkan h. Mengingat algoritma pembelajaran dasar, AdaBoost memanggilnya untuk menghasilkan hipotesis dari distribusi contoh tertentu. Jadi, hanya perlu dipertimbangkan apa hipotesis yang diinginkan untuk putaran berikutnya, dan kemudian menghasilkan distribusi contoh untuk mencapai hipotesis ini.

58

Kita dapat memperluas kerugian pointwise (titik bijaksana) untuk urutan kedua tentang h(x) = 0, ketika memperbaiki α = 1,

𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻 + ℎ | 𝑥) ≈ 𝐸_𝑦[𝑒^{−𝑦𝐻(𝑥)}(1 − 𝑦ℎ(𝑥) + 𝑦2ℎ(𝑥)²/2)|𝑥] (2. 27) 𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻 + ℎ | 𝑥) ≈ 𝐸_𝑦[𝑒−𝑦𝐻(𝑥)(1 − 𝑦ℎ(𝑥) + 1/2)|𝑥] (2. 28)

sejak y2 = 1 dan h(x)2=1.

Maka hipotesis yang sempurna adalah:

ℎ^∗(𝑥) =^{arg 𝑚𝑖𝑛} ℎ 𝑙𝑜𝑠𝑠_𝑒𝑥𝑝(𝐻 + ℎ | 𝑥) = ^{arg 𝑚𝑎𝑥} ℎ 𝐸_𝑦[𝑒^{−𝑦𝐻(𝑥)}𝑦ℎ(𝑥)|𝑥] (2. 29) = ^{arg 𝑚𝑎𝑥} ℎ 𝑒^{−𝐻(𝑥)}𝑃(𝑦 = 1|𝑥) ∙ 1 ∙ ℎ(𝑥) + 𝑒^𝐻(𝑥)𝑃(𝑦 = −1|𝑥) ∙ (−1) ∙ ℎ(𝑥)

Karena 𝑒−𝑦𝐻(𝑥) adalah bersifat konstan dalam h(x). Dengan normalisasi harapan sebagai:

ℎ^∗(𝑥) =^{arg 𝑚𝑎𝑥} ℎ

𝑒^{−𝐻(𝑥)}𝑃(𝑦 = 1|𝑥)∙1∙ℎ(𝑥)+𝑒^𝐻(𝑥)𝑃(𝑦 = −1|𝑥)∙(−1)∙ℎ(𝑥)

𝑒−𝐻(𝑥)𝑃(𝑦 = 1|𝑥)+𝑒𝐻(𝑥)𝑃(𝑦 = −1|𝑥) (2. 30)

Selanjutnya harapan ditulis ulang menggunakan istilah baru 𝑤(𝑥, 𝑦), yang diambil dari 𝑒−𝑦𝐻(𝑥)𝑃(𝑦|𝑥), sebagai:

ℎ^∗(𝑥) =^{arg 𝑚𝑎𝑥} ℎ

𝐸_{𝑤(𝑥,𝑦)~𝑒}−𝑦𝐻(𝑥)𝑃(𝑦|𝑥)[𝑦ℎ(𝑥)|𝑥]

(2. 31)

Sejak h*(x) harus +1 atau -1, solusi untuk optimasi adalah h*(x) memiliki tanda yang sama dengan y|x, yaitu:

ℎ∗(𝑥) = 𝐸_{𝑤(𝑥,𝑦)~𝑒}−𝑦𝐻(𝑥)𝑃(𝑦|𝑥)[𝑦ℎ(𝑥)|𝑥] (2. 32)

59

Seperti dapat dilihat, h* hanya melakukan klasifikasi optimal x bawah distribusi 𝑒^{−𝑦𝐻(𝑥)}𝑃(𝑦|𝑥). Oleh karena itu, 𝑒^{−𝑦𝐻(𝑥)}𝑃(𝑦|𝑥) adalah distribusi yang diinginkan untuk meminimalkan hipotesis kerugian 0/1.

Jadi, ketika hipotesis h(x) telah dipelajari dan ∝ = ¹

2ln^1−𝜖

𝜖 telah ditentukan pada saat ini, distribusi untuk tahap berikutnya harus:

𝐷_𝑡+1(𝑥) = 𝑒−𝑦(𝐻(𝑥)+∝ℎ(𝑥))𝑃(𝑦|𝑥) = 𝑒−𝑦𝐻(𝑥)𝑃(𝑦|𝑥) ∙ 𝑒−∝𝑦ℎ(𝑥) (2. 34) 𝐷_𝑡+1(𝑥) = 𝐷_𝑡(𝑥) ∙ 𝑒−∝𝑦ℎ(𝑥) (2. 35)

yang merupakan cara memperbarui distribusi dalam AdaBoost.

Tapi, mengapa mengoptimalkan kerugian kerja eksponensial untuk meminimalkan kerugian 0/1?

Sebenarnya, dapat dilihat bahwa:

ℎ∗(𝑥) =^{arg 𝑚𝑖𝑛} ℎ 𝐸_{𝑥~𝐷,𝑦}[𝑒^{−𝑦ℎ(𝑥)}] = ¹ 2ln ^{𝑃(𝑦=1|𝑥)} 𝑃(𝑦=−1|𝑥) (2. 36)

oleh karena itu didapat:

𝑠𝑖𝑔𝑛(ℎ^∗(𝑥)) =^{arg 𝑚𝑖𝑛} _𝑦 ^{𝑃(𝑦|𝑥)} (2. 37)

yang mengimplikasikan bahwa solusi optimal untuk kerugian eksponensial dicapai pada kesalahan bayesian minimum untuk masalah klasifikasi. Selain itu, dapat dilihat bahwa fungsi h yang meminimalkan kerugian eksponensial adalah model regresi logistik hingga faktor 2. Jadi, dengan mengabaikan faktor 1/2, AdaBoost juga dapat dilihat sebagai model regresi logistik tambahan yang cocok.

Perlu dicatat bahwa distribusi data tidak dikenal dalam praktek, dan algoritma AdaBoost bekerja pada sejumlah pelatihan yang diberikan dengan contoh-contoh pelatihan terbatas. Oleh karena itu, semua harapan dalam turunan di atas diambil pada contoh pelatihan, dan bobot juga dikenakan pada contoh pelatihan. Untuk algoritma dasar pembelajaran yang tidak dapat menangani pembobotan contoh pelatihan, mekanisme pengambilan ulang dari contoh yang sesuai dengan bobot yang diinginkan, dapat digunakan sebagai pengganti.

60

Algoritma AdaBoost berbasis Naïve Bayes digambarkan dengan flowchart pada Gambar 2.16, dengan masukan sejumlah data latih, data uji, dan jumlah iterasi. Pertama dilakukan inisialisasi bobot untuk setiap fitur sebesar 1 dibagi jumah data latih. Selanjutnya dilakukan perulangan sesuai masukan jumlah iterasi. Selama iterasi dilakukan pembobotan terhadap fitur data latih, karena algoritma Naïve Bayes tidak menerima bobot, maka dilakukan duplikasi fitur sesuai bobotnya sebagai data latih.

Selanjutnya data latih diklasifikasikan menggunakan algoritma pengklasifikasi (Naïve Bayes). Hitung nilai kesalahannya, jika kesalahan lebih besar dari 0,5 maka iterasi diakhiri. Jika tidak lebih besar 0,5, maka hitung koefisien kesalahan. Hitung ulang bobot fitur menggunakan koefisien kesalahan, dan dilakukan normalisasi agar bobot bernilai antara 0 sampai 1.

Proses penghitungan dilakukan sampai jumlah iterasi tercapai atau nilai kesalahan lebih dari 0,5. Setelah perulangan selesai, selanjutnya data uji diklasifikasikan menggunakan model ensemble yang terbentuk dengan koefisien bobotnya. Jika hasil klasifikasinya lebih besar atau sama dengan 0, maka diklasifikasikan ke dalam cacat. Jika hasil klasifikasinya kurang dari 0, maka diklasifikasikan ke dalam tidak cacat.

61 Mulai

Masukkan sejumlah data latih, data uji, dan jumlah iterasi T

Kemudian lakukan inisialisasi bobot pada setiap fitur (1/jumlah data latih)

t=1

t <= T

Atur ulang bobot setiap fitur menggunakan nilai bobot Dt

Hitung nilai hipotesis ht menggunakan probabilitas Naϊve Bayes

Hitung kesalahan εt

εt > 1/2

Hitung koefisien bobot

Hitung bobot baru dan lakukan normalisasi:

t++

Hitung klasifikasi data uji:

Selesai T =t-1 Ya Tidak Ya Tidak H(x) >= 0 Ya Diklasifikasikan sebagai cacat Diklasifikasikan

sebagai tidak cacat Tidak

Gambar 2.16

62

2.2.5.2 Bagging

Bootstrap aggregating (Bagging) adalah metode belajar (learning) yang

sederhana dan efektif. Bagging merupakan metode ensemble yang banyak digunakan untuk klasifikasi, dengan tujuan untuk meningkatkan akurasi pengklasifikasi dengan menggabungkan pengklasifikasi tunggal, dan hasilnya sedikit lebih baik daripada random sampling (Alfaro, Gamez, & Garcia, 2013, p. 1).

Berikut ini adalah algoritma Bagging:

Masukan: B adalah jumlah bag, T adalah data training yang berukuran N, x adalah data yang diuji.

Keluaran: Hasil klasifikasi.

Ulangi untuk b = 1, 2, ..., B

a. Buat bootstrap BSb dengan mengambil sampel dari T sejumlah N dengan penggantian.

b. Latih pengklasifikasi tunggal Cb dengan boostrap BSb

akhir perulangan

Gabungkan hasil pengklasifikasi tunggal Cb (xi); b = 1, 2, ..., B , hasil klasifikasi yang paling banyak dijadikan keputusan final klasifikasi, mengikuti rumus:

𝐶_𝑓(𝑥_𝑖) = arg 𝑚𝑎𝑥_𝑗∈𝑌∑𝐵 𝐼(𝐶_𝑏(𝑥_𝑖) = 𝑗)

𝑏=1 (2. 38)

Bagging adalah metode yang mengkombinasikan bootstrapping dan

aggregating (Alfaro, Gamez, & Garcia, 2013, p. 4). Sampel bootstrap ini

diperoleh dengan melakukan resampling dengan penggantian (with replacemants) dari dataset asli sehingga menghasilkan jumlah elemen yang sama dari dataset asli.

Bagging dapat benar-benar berguna untuk membangun pengklasifikasi menjadi lebih baik bila pada pengamatan kumpulan data latih yang terdapat noise (kegaduhan) (Alfaro, Gamez, & Garcia, 2013, p. 5). Berdasarkan penelitian, perbaikan yang besar didapat ketika menggunakan 10 bootstrap, jika

63

menggunakan lebih dari 25 bootstrap, banyak tenaga yang dihabiskan. Sehingga Bagging lebih baik digunakan untuk data yang mengandung noise (kegaduhan) dan menggunakan 10 bootstrap.

Sedangkan algoritma Bagging berbasis Naïve Bayes digambarkan dengan

flowchart pada Gambar 2.17, dengan masukan sejumlah data latih, data uji, dan

jumlah bootstrap. Pertama dibuat bootstrap, dengan melakukan random sampling dengan penggantian. Setiap bootstrap yang dibuat digunakan untuk melatih algoritma belajar tunggal (Naïve Bayes). Algoritma belajar yang sudah dilatih kemudian digabungkan untuk mengklasifikasikan data uji. Jika hasilnya lebih banyak ke kelas cacat, maka diklasifikasikan ke dalam cacat, jika tidak maka diklasifikasikan ke dalam tidak cacat.

64 Mulai

Masukkan sejumlah data latih, data uji, dan jumlah iterasi T

t=1

t <=T

Buat bootstrap menggunakan random sampling dengan

penggantian

Latih pengklasifikasi tunggal Naive Bayes menggunakan data bootstrap

t++ Ya

Klasifikasikan data uji menggunakan pengklasifikasi

tunggal yang sudah dilatih t++ Selesai Lebih banyak prediksi cacat Ya Diklasifikasikan sebagai cacat Diklasifikasikan sebagai tidak cacat

Tidak t=1 t <=T Tidak Ya Tidak Gambar 2.17

65