text
stringlengths 9
25.2k
|
|---|
## 12 Auto _encoder_
```
“The goal is to turn data into
information, and information
into insight.”
```
```
Carly Fiorina
```
Bab ini memuat materi yang relatif sulit (karena agakhigh level). Bab
ini memuat materi _autoencoder_ serta penerapannya pada pemrosesan bahasa
alami ( _natural language processing_ –NLP). Berhubung aplikasi yang diceritakan
adalah aplikasi pada NLP, kami akan memberi sedikit materi (background
_knowledge_ ) agar bisa mendapat gambaran tentang persoalan pada
domain tersebut. Bagi yang tertarik belajar NLP, kami sa _rank_ an untuk membaca
buku [64]. Teknik yang dibahas pada bab ini adalah _representation_
_learning_ untuk melakukan pengurangan dimensi pada _feature vector_ (dimensionality
reduction), teknik ini biasanya digolongkan sebagai _unsupervised_
_learning_. Artinya, _representation learning_ adalah mengubah suatu representasi
menjadi bentuk representasi lain yang ekuvalen, tetapi berdimensi lebih
rendah; sedemikian sehingga informasi yang terdapat pada representasi asli
tidak hilang/terjaga. Ide dasar teknik ini bermula dari dekomposisi matriks
pada aljabar linear.
|
## 11 Feed _forward_ Neural Network
```
“If you want to make
information stick, it’s best to
learn it, go away from it for a
while, come back to it later,
leave it behind again, and once
again return to it–to engage with
it deeply across time. Our
memories naturally degrade, but
each time you return to a
_memory_, you reactivate its neural
_network_ and help to lock it in.”
Joshua Foer
```
Penulis cukup yakin pembaca sudah menanti-nanti bagian ini. Bagian
ketiga membahas algoritma _machine learning_ yang sedang populer belakangan
ini, yaitu _artificial neural network_. Buku ini lebih berfokus pada penggunaan
artifical neural networkuntuk _supervised learning_. Pembahasan dimulai dari
hal-hal sederhana ( _single perceptron_, _multilayer perceptron_ ) sampai yang lebih
kompleks. Sebelum membaca bab ini, ada baiknya kamu mengulang membaca
bab 5 karena memberikan fondasi matematis untuk mengerti bab ini.
|
## 10 Clustering
```
“Most of us cluster somewhere in
the middle of most statistical
distributions. But there are lots
of bell curves, and pretty much
everyone is on a tail of at least
one of them. We may collect
st _range_ memorabillia or read
esoteric books, hold unsual
religious beliefs or wear
odd-sized shoes, suffer rare
diseases or enjoy obscure
moveis.”
Virginia Postrel
```
Pada bab 4, kamu sudah mempelajari salah satu teknik _clustering_ yang
cukup umum yaitu K- _mean_ s. Bab ini akan mengupas _clustering_ secara lebih
dalam. Kami sa _rank_ an kamu untuk membaca paper [41], walaupun relatif
lama, tetapi paper tersebut memberikan penjelasan yang mudah dimengerti
tentang _clustering_. Selain itu, kamu juga dapat membaca _paper_ oleh Saad et
al. [42].
_Clustering_ adalah pengelompokkan data dengan sifat yang mirip. Data
untuk _clustering_ tidak memiliki label (kelas). Secara umum, algoritma _clustering_ dapat
dikategorikan menjadi dua macam berdasarkan hasil yang dinginkan
[43]: (1) _partitional_, yaitu menentukan partisi sebanyakKdan (2) _hierarchical_,
yaitu mengelompokan data berdasarkan struktur taksonomi. Contoh algoritma _partitional_ adalah _K-means_ pada
subbab 10.1, sementara contoh
algoritma _hierarchical_ adalah _agglomerative clustering_ pada subbab 10.2.
136 10 Clustering
|
## 6 Pohon Keputusan
```
“Some _time_ s you make the right
decision, some _time_ s you make
the decision right.”
Phil McGraw
```
Bab ini akan menjelaskan salah satu varian pohon keputusan yaitu ID3
oleh Quinlan [33, 34] yang terinspirasi oleh teori informasi [35]. Algoritma ini
sudah cukup tua, tetapi layak dimengerti. ID3 adalah salah satu varian dari
_supervised learning_.
|
## Bagian III Artificial Neural Network
|
## 7 Support Vector Classifier
```
“More data beats clever
algorithms, but better data
beats more data.”
Peter Norvig
```
Saat membaca judul bab ini, kamu mungkin berpikir bahwa _support vector_
machineakan dibahas.Support vector classifierdan _support vector machine_ adalah
dua hal yang berbeda, walau kedua istilah tersebut sering digunakan
pada konteks yang mirip [20].Support vector classifiersesungguhnya
adalah konsep yang lebih sederhana. Walaupun bab ini menyinggung kulit
_support vector machine_, kami tidak membahas secara rinci. Akan tetapi, kami
berharap pembaca mampu mendapatkan intuisi. Kamu dapat menganggap
bab ini sebagai kelanjutan cerita bab 5. Referensi utama bab ini adalah buku
karangan James et al. [20].
|
## 3 Data Analytics
```
“Hiding within those mounds of
_data_ is knowl _edge_ that could
change the life of a patient, or
change the world”
Atul Butte
```
Bab ini memuat penjelasan tahapan-tahapan umum untuk analisis data,
serta beberapa karakteristik tipe data. Materi pada bab ini dapat dianggap
sebagai kerangka berpikir ( _framework_ ) atau langkah kerja. Karena buku ini
hanya bersifat pengantar, materi yang disampaikan mungkin kurang lengkap.
Penulis menya _rank_ an pembaca untuk membaca buku oleh Witten et al. [21]
dan Jeff Leek [22].
|
## 2 Fondasi Matematis
```
“He uses statistics as a drunken
man uses lamp posts – for
support rather than for
illumination.”
```
```
Andrew Lang
```
Mungkin saat pertama kali membaca bab ini, kamu merasa bab ini tidak
masuk akal atau kurang dibutuhkan. Seiring membaca buku ini, mungkin
bab ini akan sering dikunjungi kembali. Bab ini hanyalah pengingat materi
yang sudah kamu pernah pelajari saja (semacamcheatsheet). Kamu boleh
melewati bab ini apabila sudah familiar dengan materi probabilitas, statistika,
serta aljabar linier. Seharusnya, bab ini memang diberikan paling awal. Tetapi
penulis khawatir pembaca mungkin merasa buku ini tidak menarik apabila
bab ini diberikan paling awal.
Bab ini memuat sekilas tentang probabilitas, statistika, dan operasi matriks.
Tentunya untuk mengerti materi tersebut sebaiknya kamu mengambil
kuliah khusus berkaitan karena kamu diharapkan sudah memiliki cukup
latar pengetahuan, bab ini sebenarnya hanyalah sekilas pengingat. Kami akan
banyak memakai contoh-contoh dari buku Bishop [8] untuk materi probabilitas.
Penulis merekomendasikan untuk menonton kuliah _statistical inference_
(coursera) oleh Professor Brian Caffo.
|
## Biografi Penulis
JanWiraGotama Putra adalah PhD Candidate (JSPS Research Fellow)
di Computational Linguistics laboratory, Artificial Intelligence Major, Department
of Computer Science, Tokyo Institute of Technology. Sebelumnya,
penulis mendapatkan gelar sarjana di jurusan Teknik Informatika, Institut
Teknologi Bandung. Kemudian, melanjutkan magister di Tokyo Institute of
Technology dengan pendanaan MEXT scholarship. Penulis memiliki pengalaman
menulis makalah ilmiah pada bidang pemrosesan bahasa alami dan menerapkan
teknik pembelajaran mesin untuk perusahaan IT (saat _internship_ ),
e.g., _discourse processing_, klasifikasi teks, peringkasan teks, _automatic hashtag-ing_,
dan _content filtering_ ( _moderation_ ). Penulis pernah mendapatkanbest
_paper_ awarddi workshop internasional dan memenangkan lomba _data mining_
(terbuka untuk publik) di Indonesia. Penulis masih terus mempelajari teknik
_machine learning_. Buku ini adalah catatan yang ingin ia bagikan.
```
https://wiragotama.github.io/
```
|
## Bagian II Algoritma Pembelajaran Mesin
|
## 1 Pengenalan
```
“People worry that computers
will get too smart and take over
the world, but the real problem
is that they’re too stupid and
they’ve al _ready_ taken over the
world.”
Pedro Domingos
```
Penulis yakin istilah _machine learning_ atau _deep learning_ sudah tidak asing
di telinga pembaca. _Machine learning_ dan _deep learning_ adalah salah satu
materi kuliah pada jurusan Teknik Informatika atau Ilmu Komputer. Selain
mengenal kedua istilah tersebut dari perkuliahan, pembaca mungkin mengenal
istilah tersebut karena digunakan untuk pemasaran (marketing). Sebagai
permulaan, _machine learning_ dan _deep learning_ bukanlah kedua hal yang
berbeda.^1 Perlu diingat, _deep learning_ adalah bagian dari _machine learning_.
_Machine learning_ sudah diaplikasikan pada banyak hal, baik untuk klasifikasi
gambar, mobil tanpa pengemudi, klasifikasi berita, dsb. Bab ini menjelaskan
konsep paling dasar dan utama _machine learning_.
|
## 𝐄 𝐗#
Gambar 12.2: Hubungan auto _encoder_ dan singular value decomposition
(analogi).
Perhatikan, _hidden layer_ / _coding_ dapat dianalogikan sebagaiE=Uˆ Vˆ.
Dengan kata lain, kita dapat melakukan operasi _dot-product_ pada _coding_ untuk
merepresentasikan _dot-product_ pada data asliX. Ini adalah ide utama
(^5) Pada banyak literatur, kumpulan _weight matrices_ ANN sering dilambangkan den-
ganθ
(^6) Hanya sebuah analogi.
168 12 Auto _encoder_
_autoencoder_, yaitu meng-aproksimasi/meng _kompresi data_ asli menjadi bentuk
lebih kecil _coding_. Kemudian, operasi pada bentuk _coding_ merepresentasikan
operasi pada data sebenarnya.
_Autoencoder_ terdiri dari _encoder_ (sebuah _neural network_ ) dan _decoder_
(sebuah _neural network_ ). _Encoder_ merubah _input_ ke dalam bentuk dimensi
lebih kecil (dapat dianggap sebagai kompresi). _Decoder_ berusaha merekonstruksi _coding_ menjadi
bentuk aslinya. Secara matematis, kita dapat menulis
_autoencoder_ sebagai persamaan 12.6, dimana dec melambangkan _decoder_, enc
melambangkan _encoder_ danx adalah _input_. _Encoder_ diberikan pada persamaan
12.7 yang berarti melewatkan _input_ pada suatu _layer_ di _neural network_ untuk
menghasilkan representasixberdimensi rendah, disebut _coding_
c.Udanαmelambangkan _weight matrix_ dan _bias_.
```
f(d,θ) = dec(enc(x)) (12.6)
```
```
c= enc(x) =g(x,U,α) (12.7)
```
Representasicini kemudian dilewatkan lagi pada suatu _layer_ untuk merekonstruksi
kembali _input_, kita sebut sebagai _decoder_. _Decoder_ diberikan pada persamaan
12.8 dimanaWdanβmelambangkan _weight matrix_ dan _bias_. Baik
pada fungsi _encoder_ dan _decoder_,σmelambangkan fungsi aktivasi.
```
f(d,θ) = dec(c) =h(c,W,β) (12.8)
```
Pada contoh sederhana ini, _encoder_ dan _decoder_ diilustrasikan sebagai sebuah
_layer_. Kenyataannya, _encoder_ dan _decoder_ dapat diganti menggunakan sebuah
_neural network_ dengan arsitektur kompleks.
Sekarang kamu mungkin bertanya-tanya, bila auto _encoder_ melakukan
hal serupa seperti _singular value decomposition_, untuk apa kita menggunakan _autoencoder_ ?
(mengapa tidak menggunakan aljabar saja?) Berbeda
dengan teknik SVD, teknik _autoencoder_ dapat juga mempelajari fitur nonlinear.^7
Pada penggunaan praktis, _autoencoder_ adalah _neural network_ yang
cukup kompleks (memiliki banyak _hidden layer_ ). Dengan demikian, kita dapat
”mengetahui”berbagai macam representasiatau transformasi data.
_Framework autoencoder_ yang disampaikan sebelumnya adalah framework
dasar. Pada kenyataannya, masih banyak ide lainnya yang bekerja dengan
prinsip yang sama untuk mencari _coding_ pada permasalahan khusus. _Output_
dari _neural network_ juga bisa tidak sama _input_ -nya, tetapi tergantung permasalahan
(kami akan memberikan contoh persoalan _word embedding_ ). Selain
itu, _autoencoder_ juga relatif fleksibel; dalam artian saat menambahkan data
baru, kita hanya perlu memperbaharui parameter _autoencoder_ saja. Kami
sa _rank_ an untuk membaca _paper_ [72, 73] perihal penjelasan lebih lengkap tentang
perbedaan dan persamaan SVD dan _autoencoder_ secara lebih matematis.
Secara sederhana, _representation learning_ adalah teknik untuk mengkompresi _input_ ke
dalam dimensi lebih rendah tanpa (diharapkan) ada kehilangan
(^7) Hal ini abstrak untuk dijelaskan karena membutuhkan pengalaman.
```
12.4 Resisting Perturbation 169
```
informasi. Operasi vektor (dan lainnya) pada level _coding_ merepresentasikan
operasi pada bentuk aslinya. Untuk pembahasan _autoencoder_ secara lebih
matematis, kamu dapat membaca pranala ini.^8 Setelah _autoencoder_ dilatih,
pada umumnya _encoder_ dapat digunakan untuk hal lainnya juga, e.g., klasifikasi
kelas gambar.
|
## 𝐗 Encoder Decoder
|
## 13 Arsitektur Neural Network
```
“As students cross the threshold
from outside to insider, they also
cross the threshold from
superficial learning motivated by
grades to deep learning
motivated by engagement with
questions. Their transformation
entails an awakening–even,
perhaps, a falling in love.”
John C. Bean
```
Seperti yang sudah dijelaskan pada bab 9 dan bab 12, data memiliki karakteristik
(dari segi struktur) misal _sequential data_, _compositional_ data, dsb.
Terdapat arsitektur khusus _artificial neural network_ (ANN) untuk menyelesaikan
persoalan pada tipe data tertentu. Pada bab ini, kami akan memberikan
beberapa contoh variasi arsitektur ANN yang cocok untuk tipe data tertentu.
Penulis akan berusaha menjelaskan semaksimal mungkin ide-ide penting
pada masing-masing arsitektur. Tujuan bab ini adalah memberikan pengetahuan
konseptual (intuisi). Pembaca harus mengeksplorasi tutorial pemrograman
untuk mampu mengimplementasikan arsitektur-arsitektur ini. Penjelasan
pada bab ini bersifat abstrak dan kamu harus mengerti penjelasan
bab-bab sebelumnya untuk mengerti konsep pada bab ini.
|
## 9 Seleksi Fitur dan Metode Evaluasi
```
“The key to artificial intelligence
has always been the
_representation_.”
```
```
Jeff Hawkins
```
Bab ini membahas beberapa tips dan trik yang sebenarnya sudah disinggung
pada bab 3 dan bab 5. Hanya saja, beberapa hal lebih baik dijelaskan
secara lebih mendalam ketika sudah mempelajari beberapa algoritma pembelajaran
mesin, seperti pentingnya _feature engineering_, _feature selection_ dan
penjelasan lebih lanjut _cross validation_. Kamu dapat menganggap bab ini sebagai
kelanjutan tips dan trik pembelajaran mesin lanjutan bab 3 dan bab 5.
|
### Edisi1.4 ( 17 Agustus2020)
|
## 5 Model Linear
```
“Some _time_ s an entirely
inaccu _rate_ formula is a handy
way to move you in the right
direction if it offers simplicity.”
```
```
Scott Adams
```
Bab ini membahas tentang model linear (algoritma parametrik), sebagai
contoh pembelajaran yang sederhana karena cukup mudah dipahami idenya.
Bab ini juga membahas _error function_ dan _stochastic gradient descent_. Dimulai
dari bab ini, kita akan memasuki materi lebih serius. Materi pada bab ini
dijelaskan dengan sangat baik dan mendalam pada bukuAn Introduction to
Statistical Learning[20].
|
## Referensi
```
[1] Yoav Goldberg. _Neural Network Methods in Natural Language Processing_.
Morgan & Claypool Publishers, 2017.
[2] Peter Linz. _An Introduction to Formal Language and Automata_. Jones
and Bartlett Publishers, Inc., USA, 2006.
[3] Ronald Brachman and Hector Levesque.Knowl _edge_ Representation and
Reasoning. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA,
2004.
[4] Tom Mitchell. _Machine Learning_. McGraw-Hill, 1997.
[5] Stuart Russel and Peter Norvig. _Artificial Intelligence: A Modern Approach_.
Prentice Hall, 1995.
[6] Jonathan Gratch and Stacell Marsella. Computationally modelling human
emotion. _Communications of the ACM_, 57(12):71–99, 2014.
[7] Masayu Leylia Khodra and Dessi Puji Lestari. Odd semester lecture on
_machine learning_. Lecture of Institute Teknologi Bandung, 2015.
[8] Christopher M. Bishop. Pattern Recognition and Machine Learning.
Springer, 2006.
[9] Sumio Watanabe and Hidetoshi Nishimori. Fall lecture note on statistical
_learning_ theory. Lecture note for Tokyo Institute of Technology,
2016.
[10] Brian Caffo. Statistical Inference for Data Science. Lean Publishing,
2015.
[11] Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning.
MIT Press, 2016.
[12] Daniel Jurafsky and James H. Martin. _Speech and Language Processing_
Second Edition. Prentice Hall, 2009.
[13] Nils Reimers and Iryna Gurevych. Reporting score distributions makes
a difference: Performance study of LSTM- _network_ s for sequence tagging.
InProceedings of the 2017 Conference on Empirical Methods in Natural
Language Processing, pages 338–348, Copenhagen, Denmark, September
```
2017. Association for Computational Linguistics.
228 Referensi
```
[14] Rotem Dror, Gili Baumer, Segev Shlomov, and Roi Reichart. The hitchhiker’s
guide to testing statistical significance in natural language processing.
InProceedings of the 56th Annual Meeting of the Association
for Computational Linguistics (Volume 1: Long Papers), pages 1383–
1392, Melbourne, Australia, July 2018. Association for Computational
Linguistics.
[15] Rotem Dror, Segev Shlomov, and Roi Reichart. Deep dominance - how
to properly compare deep neural models. InProceedings of the 57th
Annual Meeting of the Association for Computational Linguistics, pages
2773–2785, Florence, Italy, July 2019. Association for Computational
Linguistics.
[16] Thomas M. Cover and Joy A. Thomas. _Elements of Information Theory_.
Wiley, 1991.
[17] Hidetoshi Nishimori.Statistical Physics of Spin Glasses and Information
Processing: An Introduction. Clarendon Press, 2001.
[18] Sharon L. Myres Ronald E. Walpole, Raymond H. Myers and Keying
Ya. Probability and Statistics for Engineers and Scientists. Prentice
Hall, 2012.
[19] Gilbert Strang. Linear algebra and its applications. Thomson,
Brooks/Cole, Belmont, CA, 2006.
[20] G. James, D. Witten, T. Hastie, and R. Tibshirani.An Introduction to
Statistical Learning, with applications in R. Springer, 2013.
[21] Ian H. Witten, Eibe F _rank_, and Mark A. Hall.Data Minin gg: Practical
_Machine Learning_ Tools and Techniques. Morgan Kaufmann Publishers
Inc., San Francisco, CA, USA, 3rd edition, 2011.
[22] Jeff Leek. _The Elements of Data Analytic Style_. Leanpub, 2015.
[23] Takao Terano and Tsuyoshi Murata. Spring lecture on machine learning.
Lecture of Tokyo Institute of Technology, 2017.
[24] Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: A
method for automatic evaluation of machine translation. InProceedings
of the 40th Annual Meeting on Association for Computational Linguistics,
ACL ’02, pages 311–318, Stroudsburg, PA, USA, 2002. Association
for Computational Linguistics.
[25] Chin-Yew Lin. Rouge: A package for automatic evaluation of summaries.
InProc. ACL workshop on Text Summarization Branches Out, page 10,
2004.
[26] Irina Rish. An empirical study of the naive bayes classifier. InIJCAI
2001 workshop on empirical methods in artificial intelligence, volume 3,
pages 41–46. IBM New York, 2001.
[27] J. A. Hartigan and M. A. Wong. A k- _mean_ s clustering algorithm.JSTOR:
Applied Statistics, 28(1):100–108, 1979.
[28] T. Cover and P. Hart. Nearest neighbor pattern classification. IEEE
Trans. Inf. Theor., 13(1):21–27, September 2006.
[29] Mohammad S. Sorower. A literature survey on algorithms for multilabel
_learning_. 2010.
```
```
Referensi 229
```
[30] John Duchi, Elad Hazan, and Yoram Singer. Adaptive sub _gradient_
methods for online learning and stochastic optimization, 2010.
[31] Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine
_Learning_, 20(3):273–297, Sep 1995.
[32] Marti A. Hearst. Support vector machines. _IEEE Intelligent Systems_,
13(4):18–28, July 1998.
[33] J. R. Quilan. Discovering rules by induction from large collections of
examples. Edinburgh University Press, 1979.
[34] J.R. Quinlan. Induction of decision trees. Mach. Learn., 1(1):81–106,
March 1986.
[35] C. E. Shannon. A mathematical theory of communication. The Bell
System Technical Journal, 27(3):379–423, 1948.
[36] Takao Terano and Tsuyoshi Murata. Spring lecture on machine learning.
Lecture of Tokyo Institute of Technology, 2017.
[37] L. R. Rabiner and B. H. Juang. An introduction to hidden markov
_model_ s. _IEEE ASSp Magazine_, 1986.
[38] James Allen. Natural Language Understanding. Benjamin-Cummings
Publishing Co., Inc., 1995.
[39] Eliyahu Kiperwasser and Yoav Goldberg. Simple and accu _rate_ dependency
parsing using bidirectional LSTM feature representations.Trans _action_ s
of the Association for Computational Linguistics, 4:313–327,
2016.
[40] Vishal M. Patel, Raghuraman Gopalan, Ruonan Li, and Rama Chellappa.
Visual domain adaptation: A survey of recent advances. IEEE
Signal Process. Mag., 32(3):53–69, 2015.
[41] George Karypis Michael Steinbach and Vipin Kumar. A comparison of
document clustering techniques. InKDD Workshop on Text Mining,
pages 525 – 526, 2000.
[42] Omer I. E. Mohamed Fathi H. Saad and Rafa E. Al-Qutaish. Comparison
of hierarchical agglomerative algorithms for clustering medical
documents. International Journal of Software Engineering and Applications
(IJSEA), 3(3), 2012.
[43] Rajeev Rastogi Sudipto Guha and Kyuseok Shim. Cure: An efficient
_clustering_ algorithm for large databases. InProceedings of ACMSIGMOD
International Conference on Management of Data, pages 73 – 84,
1998.
[44] Jack D. Cowan. Neural networks: The early days. InProceedings of
Advances in Neural Information Processing Systems 2, 1989.
[45] Amir Atiya. Learning Algorithms for Neural Network. PhD thesis,
California Institute of Technology, 1994.
[46] Al. Cripps. Using artificial neural nets to predict academic performance.
In _Proceedings of the 1996 ACM Symposium on Applied Computing_,
pages 33–37, 1996.
[47] Thomas Mikolov. Statistical Language Models Based on Neural Networks.
PhD thesis, Brno University of Technology, 2012.
230 Referensi
```
[48] Kai Chen Greg Corrado Thomas Mikolov, Ilya Sutskever and Jeffrey
Dean. Distributed representations of words and phrases and their compositionality.
In _Proceedings of CoRR_, 2013.
[49] Gred Corrado Thomas Mikolov, Kai Chen and Jeffrey Dean. Efficient
estimation of word representations in vector space. InProceedings of
_CoRR_, 2013.
[50] Kai Yu. Large-scale deep learning at baidu. InProceedings of the 22nd
ACM International Conference on Information and Knowl _edge_ Management,
pages 2211–2212, 2013.
[51] M. A. Aizerman, E. A. Braverman, and L. Rozonoer. Theoretical foundations
of the potential function method in pattern recognition learning.
In _Automation and Remote Control,_, number 25, pages 821–837, 1964.
[52] F. Rosenblatt. The perceptron: A probabilistic model for information
storage and organization in the brain. _Psychological Review_, pages 65–
386, 1958.
[53] Marvin L. Minsky and Seymour A. Papert. _Perceptrons: Expanded Edition_.
MIT Press, Cambridge, MA, USA, 1988.
[54] D. E. Rumelhart, G. E. Hinton, and R. J. Williams. Parallel distributed
processing: Explo _ratio_ ns in the microstructure of cognition, vol. 1. chapter
_Learning_ Internal Representations by Error Propagation, pages 318–
```
362. MIT Press, Cambridge, MA, USA, 1986.
[55] Tao Lei, Regina Barzilay, and Tommi Jaakkola. Rationalizing neural
_prediction_ s. InProceedings of the 2016 Conference on Empirical
Methods in Natural Language Processing, pages 107–117, Austin, Texas,
November 2016. Association for Computational Linguistics.
[56] David Alvarez-Melis and Tommi Jaakkola. A causal framework for explaining
the predictions of black-box sequence-to-sequence models. In
Proceedings of the 2017 Conference on Empirical Methods in Natural
Language Processing, pages 412–421, Copenhagen, Denmark, September
2017. Association for Computational Linguistics.
[57] Dzmitry Bahdanau, KyungHyun Cho, and Yoshua Bengio. Neural machine
translation by jointly learning to align and translate. InProceedings
of the International Conference on Learning and Representation
(ICLR), 2015.
[58] Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches
to attention-based neural machine translation. InProceedings
of the 2015 Conference on Empirical Methods in Natural Language Processing,
pages 1412–1421, Lisbon, Portugal, September 2015. Association
for Computational Linguistics.
[59] Finale Doshi-Velez and Been Kim. A roadmap for a rigorous science of
_interpretability_. In _ArXiv e-prints_.
[60] Jeffrey L. Elman. Learning and development in neural networks: The
importance of starting small. _Journal of Cognition_, (48):71–99, 1993.
[61] Yoshua Bengio, J ́erˆome Louradour, Ronan Collobert, and Jason Weston.
_Curriculum learning_. InProceedings of the 26th Annual International
```
Referensi 231
```
Conference on Machine Learning, ICML ’09, pages 41–48, New York,
NY, USA, 2009. ACM.
[62] Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and
Ruslan Salakhutdinov. Dropout: A simple way to pr _event_ neural networks
from overfitting.J. Mach. Learn. Res., 15(1):1929–1958, January
2014.
[63] Dzmitry Bahdanau Kyunghyun Cho, Bart van Merrienboer and Yoshua
Bengio. On the properties of neural machine translation: Encoder–
_decoder_ approaches. InProceedings of SSST-8, Eighth Workshop on
Syntax, Semantics and Structure in Statistical Translation, pages 103–
111, Doha, Qatar, October 2014. Association for Computational Lin-
guistics.
[64] Christopher D. Manning and Hinrich Schutze.Foundations of Statistical
Natural Language Processing. MIT Press, 1999.
[65] Prabhakar Raghavan Christopher D. Manning and Hinrich Schutze.An
Introduction to Information Retrieval. Cambridge UP, 2009.
[66] Andrew Y. Ng Richard Socher, Cliff Chiung-Yu Lin and Christopher D.
Manning. Parsing natural scenes and natural language with recursive
_neural network_ s. InProceedings of the 28thInternational Conference on
_Machine Learning_, 2011.
[67] Jean Y. Wu Jason Chuang Richard Socher, Alex Perelygin and Christopher
D. Manning. Recursive deep models for semantic compositionality
over a sen _time_ nt treebank. InProceedings of the Emperical Methods in
Natural Language Processing, 2013.
[68] Erhc H. Huang Andrew Y. Ng Richard Socher, Jeffrey Pennington and
Christoper D. Manning. Semi- _supervised_ recursive auto _encoder_ s for predicting
sen _time_ nt distributions. InProceedings of the Emperical Methods
in Natural Language Processing, 2011.
[69] Quoc Le and Tomas Mikolov. Distributed representations of sentences
and documents. InProceedings of the 31stInternational Conference on
_Machine Learning_, 2014.
[70] Richard Socher Jeffrey Pennington and Christopher D. Manning. Glove:
Global vectors for word representation. InProceedings of the Emperical
Methods in Natural Language Processing, pages 1532 – 1543, 2014.
[71] Yoshua Bengio, R ́ejean Ducharme, Pascal Vincent, and Christian Janvin.
A neural probabilistic language model. J. Mach. Learn. Res.,
3:1137–1155, March 2003.
[72] Omer Levy, Yoav Goldberg, and Ido Dagan. Improving distributional
similarity with lessons learned from word embeddings.Trans _action_ s of
the Association for Computational Linguistics, 3:211–225, 2015.
[73] Guoqiang Zhong, Li-Na Wang, Xiao Ling, and Junyu Dong. An overview
on data representation learning: From traditional feature learning to
recent deep learning.The Journal of Finance and Data Science, 2(4):265
- 278, 2016.
232 Referensi
```
[74] Peter D. Turney and Patrick Pantel. From frequency to meaning: Vector
_space_ models of semantics. Journal of Artificial Intelligence Research,
(37):141–188, 2010.
[75] Jan Wira Gotama Putra and Takenobu Tokunaga. Evaluating text
coherence based on semantic similarity graph. In Proceedings of
TextGraphs-11: the Workshop on Graph-based Methods for Natural Language
Processing, pages 76–85, Vancouver, Canada, August 2017. Association
for Computational Linguistics.
[76] Y. LeCun and Y. Bengio. Convolutional networks for images, speech,
and time-series. In M. A. Arbib, editor,The Handbook of Brain Theory
and Neural Networks. MIT Press, 1995.
[77] Jeffrey L. Elman. Finding structure in time. Cognitive Science,
14(2):179–211, 1990.
[78] Sepp Hochreiter and J ̈urgen Schmidhuber. Long short- _term_ memory.
_Neural Comput._, 9(8):1735–1780, November 1997.
[79] Paul J. Werbos. Backpropagation through time: what does it do and
how to do it. In _Proceedings of IEEE_, volume 78, pages 1550–1560, 1990.
[80] Caglar Gulcehre Dzmitry Bahdanau Fethi Bougares HolgerSchwenk
Kyunghyun Cho, Bart van Merrienboer and Yoshua Bengio. Learning
phrase representations using rnn encoder– _decoder_ for statistical machine
translation. InProceedings of the 2014 Conference on Empirical Methods
in Natural Language Processing (EMNLP), pages 1724–1734, Doha,
Qatar, October 2014. Association for Computational Linguistics.
[81] Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence
_learning_ with neural networks. InProceedings of the 27th International
Conference on Neural Information Processing Systems, NIPS’14, pages
3104–3112, Cambridge, MA, USA, 2014. MIT Press.
[82] Yan Shao, Christian Hardmeier, J ̈org Tiedemann, and Joakim Nivre.
Character-based joint segmentation and pos tagging for chinese using
_bidirectional_ rnn-crf. InProceedings of the Eighth International Joint
Conference on Natural Language Processing (Volume 1: Long Papers),
pages 173–183, Taipei, Taiwan, November 2017. Asian Fede _ratio_ n of
Natural Language Processing.
[83] To _bias_ Horsmann and Torsten Zesch. Do lstms really work so well for
pos tagging? – a replication study. InProceedings of the 2017 Conference
on Empirical Methods in Natural Language Processing, pages 727–736,
Copenhagen, Denmark, September 2017. Association for Computational
Linguistics.
[84] Barbara Plank, Anders Søgaard, and Yoav Goldberg. Multilingual partof-speech
_tagging_ with bidirectional long short- _term_ memory models and
auxiliary loss. InProceedings of the 54th Annual Meeting of the Association
for Computational Linguistics, ACL 2016, August 7-12, 2016,
Berlin, Germany, Volume 2: Short Papers, 2016.
[85] Ryohei Sasano Hiroya Takamura Yuta Kikuchi, Graham Neubig and
Manabu Okumura. Controlling output length in neural encoder-
```
```
Referensi 233
```
_decoder_ s. InProceedings of the 2016 Conference on Empirical Methods
in Natural Language Processing, pages 1328–1338, Austin, Texas,
November 2016. Association for Computational Linguistics.
[86] Ramesh Nallapati, Bowen Zhou, C ́ıcero Nogueira dos Santos, and
aglar G ̈ulehre and Bing Xiang. Abstractive text summarization using
sequence-to-sequence rnns and beyond. In _CoNLL_, 2016.
[87] Yan-Kai Lin Cun-Chao Tu Yu Zhao Zhi-Yuan Liu Ayana, Shi-Qi Shen
and Mao-Song Sun. Recent advances on neural headline gene _ratio_ n.
_Journal of Computer Science and Technology_, 32(4):768–784, Jul 2017.
[88] Chlo ́e Kiddon, Luke Zettlemoyer, and Yejin Choi. Globally coherent
text gene _ratio_ n with neural checklist models. InProceedings of the
2016 Conference on Empirical Methods in Natural Language Processing,
pages 329–339, Austin, Texas, November 2016. Association for Computational
Linguistics.
[89] Xiaojun Wan Jiwei Tan and Jianguo Xiao. Abstractive document summarization
with a graph-based attentional neural model. InProceedings
of the 55th Annual Meeting of the Association for Computational Linguistics
(Volume 1: Long Papers), pages 1171–1181, Vancouver, Canada,
July 2017. Association for Computational Linguistics.
[90] Oriol Vinyals, Alexander Toshev, Samy Bengio, and Dumitru Erhan.
Show and tell: A neural image caption generator. 2015 IEEE Conference
on Computer Vision and Pattern Recognition (CVPR), pages
3156–3164, 2015.
[91] Zichao Yang, Diyi Yang, Chris Dyer, Xiaodong He, Alex Smola, and
Eduard Hovy. Hierarchical attention networks for document classification.
InProceedings of the 2016 Conference of the North American
Chapter of the Association for Computational Linguistics: Human Language
Technologies, pages 1480–1489, San Diego, California, June 2016.
Association for Computational Linguistics.
[92] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion
Jones, Aidan N Gomez, L ukasz Kaiser, and Illia Polosukhin. Attention
is all you need. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach,
R. Fergus, S. Vishwanathan, and R. Garnett, editors,Advances
in Neural Information Processing Systems 30, pages 5998–6008. Curran
Associates, Inc., 2017.
[93] Karl Weiss, Taghi M. Khoshgoftaar, and DingDing Wang. A survey of
_transfer learning_. _Journal of Big Data_, 3(1):9, May 2016.
[94] Sebastian Ruder, Matthew E. Peters, Swabha Swayamdipta, and
Thomas Wolf. Transfer learning in natural language processing. In
Proceedings of the 2019 Conference of the North American Chapter of
the Association for Computational Linguistics: Tutorials, pages 15–18,
Minneapolis, Minnesota, June 2019. Association for Computational Lin-
guistics.
234 Referensi
[95] Ronan Collobert, Jason Weston, L ́eon Bottou, Michael Karlen, Koray
Kavukcuoglu, and Pavel Kuksa. Natural language processing (almost)
from scratch.J. Mach. Learn. Res., 12:2493–2537, November 2011.
[96] Daxiang Dong, Hua Wu, Wei He, Dianhai Yu, and Haifeng Wang. Multi _task_
_learning_ for multiple language translation. InProceedings of the
53rd Annual Meeting of the Association for Computational Linguistics
and the 7th International Joint Conference on Natural Language
Processing (Volume 1: Long Papers), pages 1723–1732. Association for
Computational Linguistics, 2015.
[97] Pengfei Liu, Xipeng Qiu, and Xuanjing Huang. Adversarial multi- _task_
_learning_ for text classification. InProceedings of the 55th Annual Meeting
of the Association for Computational Linguistics (Volume 1: Long
Papers), pages 1–10. Association for Computational Linguistics, 2017.
[98] Anne Lauscher, Goran Glavaˇs, Simone Paolo Ponzetto, and Kai Eckert.
Investigating the role of argumentation in the rhetorical analysis
of scientific publications with neural multi- _task_ learning models. In
Proceedings of the 2018 Conference on Empirical Methods in Natural
Language Processing, pages 3326–3338. Association for Computational
Linguistics, 2018.
[99] Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi- _task_ learning using
_uncertainty_ to weigh losses for scene geometry and semantics. In 2018
IEEE Conference on Computer Vision and Pattern Recognition, CVPR
2018, Salt Lake City, UT, USA, June 18-22, 2018, pages 7482–7491,
2018.
[100] Arda Antikacioglu and R. Ravi. Post processing recommender systems
for diversity. InProceedings of the 23rd ACM SIGKDD International
Conference on Knowl _edge_ Discovery and Data Mining, KDD 17, page
707716, New York, NY, USA, 2017. Association for Computing Machin-
ery.
[101] Daniel Billsus and Michael J. Pazzani. The adaptive web. chapter Adaptive
News Access, pages 550–570. Springer-Verlag, Berlin, Heidelberg,
2007.
[102] Paul Resnick and Hal R. Varian. Recommender systems. Commun.
ACM, 40(3):56–58, March 1997.
[103] Daniar Asanov. Algorithms and methods in recommender systems.
Berlin Institute of Technology, 2011.
[104] Charu C. Aggrawal. Recommender Systems: The Textbook. Springer
International Publishing Switzerland, 2016.
[105] Eduard Hovy and Chin-Yew Lin. Automated text summarization and
the summarist system. InProceedings of a Workshop on Held at Baltimore,
Maryland: October 13-15, 1998, TIPSTER ’98, pages 197–214,
Stroudsburg, PA, USA, 1998. Association for Computational Linguis-
tics.
```
Referensi 235
```
[106] Liang Zhou and Eduard Hovy. Template- _filter_ ed headline summarization.
InIn the Proceedings of the ACL workshop, Text Summarization
Branches Out, pages 56–60, 2004.
[107] Amin Mantrach Carlos A. Colmenares, Marina Litvak and Fabrizio Silvestri.
Heads: Headline gene _ratio_ n as sequence prediction using an abstract
feature-rich space. InProceedings of the 2015 Conference of the
North American Chapter of the Association for Computational Linguistics:
Human Language Technologies, pages 133–142, Denver, Colorado,
May–June 2015. Association for Computational Linguistics.
[108] Daniele Pighin Enrique Alfonseca and Guillermo Garrido. Heady: News
headline abstr _action_ through event pattern clustering. InProceedings of
the 51st Annual Meeting of the Association for Computational Linguistics
(Volume 1: Long Papers), pages 1243–1253, Sofia, Bulgaria, August
2013. Association for Computational Linguistics.
[109] Pierre-Etienne Genest and Guy Lapalme. Framework for abstractive
summarization using text-to-text gene _ratio_ n. In Proceedings of the
Workshop on Monolingual Text-To-Text Gene _ratio_ n, pages 64–73, Portland,
Oregon, June 2011. Association for Computational Linguistics.
[110] Shufeng Xiong and Donghong Ji. Query-focused multi-document summarization
using hypergraph-based ranking. Inf. Process. Manage.,
52(4):670–681, July 2016.
[111] David Zajic, Bonnie J. Dorr, and Richard Schwartz. Bbn/umd at duc2004:
Topiary. InProceedings of the North Americal Chapter of the
Association for Computational Linguistics Workshop on Document Understanding,
pages 112–119, 2004.
[112] Simone Teufel and Marc Moens. Argumentative classification of extracted
_sentence_ s as a first step towards flexible abstr _acting_. InAdvances
in automatic Text Summarization, pages 155–171. MIT Press,
1999.
[113] Bonnie J. Dorr, David Zajic, and Richard Schwartz. H _edge_ trimmer:
A parse-and-trim approach to headline gene _ratio_ n. In Dragomir Radev
and Simone Teufel, editors,Proceedings of the HLT-NAACL 03 Text
Summarization Workshop, pages 1–8, 2003.
[114] Jurij Leskovec, Natasa Milic-Frayling, and Marko Grobelnik. Extr _acting_
summary sentences based on the document semantic graph. Micro _soft_
Research, 2005.
[115] Jan Wira Gotama Putra. Rhetorical sentence classification for automatic
title gene _ratio_ n in scientific article. _TELKOMNIKA_, 15(2):656–
664, 2017.
[116] Jan Pedersen Julian Kupiec and Francine Chen. A trainable document
summarizer. InProceedings of the 18th Annual International ACM
SIGIR Conference on Research and Development in Information Retrieval,
SIGIR ’95, pages 68–73, New York, NY, USA, 1995. ACM.
[117] Hans-Martin Ramsl Daraksha Parveen and Michael Strube. Topical
coherence for graph-based extractive summarization. InConference on
236 Referensi
Empirical Methods in Natural Language Processing, pages 1949–1954.
The Association for Computational Linguistics, 2015.
[118] Simone Teufel and Marc Moens. Summarizing scientific articles: Experiments
with relevance and rhetorical status. Comput. Linguist.,
28(4):409–445, December 2002.
[119] DiarmuidO S ́eaghdha and Simone Teufel. Un _supervised learning_ of ́
rhetorical structure with un-topic models. InProceedings of COLING
2014, the 25th International Conference on Computational Linguistics:
Technical Papers, pages 2–13, Dublin, Ireland, August 2014. Dublin City
University and Association for Computational Linguistics.
[120] Vibhu O. Mittal Michele Banko and Michael J. Witbrock. Headline
_generation_ based on statistical translation. InProceedings of the 38th
Annual Meeting on Association for Computational Linguistics, ACL ’00,
pages 318–325, Stroudsburg, PA, USA, 2000. Association for Computational
Linguistics.
[121] Jianpeng Cheng and Mirella Lapata. Neural summarization by extr _acting_
_sentence_ s and words. _CoRR_, abs/1603.07252, 2016.
[122] Christopher D. Manning. Part-of-speech tagging from 97% to 100%: Is
it time for some linguistics? InProceedings of the 12th International
Conference on Computational Linguistics and Intelligent Text Processing
- Volume Part I, CICLing’11, pages 171–189, Berlin, Heidelberg,
2011. Springer-Verlag.
[123] Lev Ratinov and Dan Roth. De _sign_ challenges and misconceptions in
_named entity recognition_. InProceedings of the Thirteenth Conference
on Computational Natural Language Learning, CoNLL ’09, pages 147–
155, Stroudsburg, PA, USA, 2009. Association for Computational Lin-
guistics.
[124] Jiwei Li and Dan Jurafsky. Neural net models of open-domain discourse
coherence. InProceedings of the 2017 Conference on Empirical Methods
in Natural Language Processing, pages 198–209, Copenhagen, Denmark,
September 2017. Association for Computational Linguistics.
|
## Bagian I Pengetahuan Dasar
|
## 4 Algoritma Dasar
```
“It is a capital mistake to
theorize before one has data.”
Arthur Conan Doyle
```
Sebelum masuk ke algoritma _machine learning_ yang cukup modern/
matematis, kami akan memberi contoh algoritma yang lebih mudah yaitu
_Naive Bayes_, _K-means_, danK-nearest-neighbor. Algoritma-algoritma
ini tergolongnon-parametrik. Bab ini akan memuat contoh sederhana _supervised_ dan _unsupervised_
_learning_. Mudah-mudahan bab ini memberikan kamu
gambaran aplikasi _machine learning_ sederhana.
|
## Bagian IV Aplikasi dan Topik Tambahan
|
## 8 Hidden Markov Model
```
“Probability is expectation
founded upon partial knowl _edge_.
A perfect acquaintance with all
the circumstances affecting the
occurrence of an event would
change expectation into
certainty, and leave neither room
nor demand for a theory of
probabilities.”
George Boole
```
_Hidden Markov Model_ (HMM) adalah algoritma yang relatif cukup lama
[37]. Tetapi algoritma ini penting untuk diketahui karena digunakan sebagai
teknik dasar untukautomatic speech recognition (ASR) danpart-of-speech
(POS) _tagging_. Bab ini akan membahas ide dasar HMM serta aplikasinya pada
POS _tagging_ ( _natural language processing_ ). Aplikasi tersebut dipilih karena
penulis lebih familiar dengan POS _tagging_. Selain itu, POS _tagging_ relatif lebih
mudah dipahami dibandingkan aplikasi HMM pada ASR.^1 HMM adalah kasus
spesialBayesian Inference[12, 38, 5]. Untuk mengertiBayesian Inference,
ada baiknya kamu membaca materi _graphical model_ pada bukupattern
recognition and machine learning[8]. Bab ini relatif lebih kompleks secara
matematis dibanding bab-bab sebelumnya. Oleh karena itu, kami harap kamu
membaca dengan sabar.
|
## Kata Pengantar
Buku ini ditujukan sebagai bahan pengantar (atau penunjang) mata kuliah
_machine learning_ untuk mahasiswa di Indonesia, khususnya tingkat sarjana
(tidak menutup kemungkinan digunakan untuk tingkat pascasarjana). Buku
ini hanya merupakan komplemen, bukan sumber informasi utama. Buku ini
memuat materi dasar _machine learning_, yang ditulis sedemikian rupa sehingga
pembaca mampu mendapatkanintuisi. Materi pada buku ini tidaklah dalam
(tapi tidak dangkal); artinya, pembaca masih harus membaca buku-buku lainnya
untuk mendapatkan pemahaman lebih dalam.
Walaupun tidak sempurna, mudah-mudahan buku ini mampu memberi inspirasi.
Anggap saja membaca buku ini seperti sedang membaca “ _light novel_ ”.
Penulis ingin buku ini bisa menjadi _pointer_ ; i.e. dengan membaca buku ini, diharapkan
kawan-kawan juga mengetahui harus belajar apa secara lebih jauh.
Setelah membaca buku ini, pembaca diharapkan mampu membaca literatur
_machine learning_ yang dijelaskan secara lebih matematis ataupun mendalam
(kami memberi rekomendasi bacaan lanjutan).
Di Indonesia, penulis banyak mendengar baik dari teman, junior, senior,
dll; suatu pernyataan “kuliah mengajari teori saja, praktiknya kurang, dan
tidak relevan dengan industri.” Tentu saja pernyataan ini cukup benar, tetapi
karena permikiran semacam ini terkadang kita tidak benar-benar mengerti
permasalahan. Ketika mengalami kendala, kita buntu saat mencari solusi
karena fondasi yang tidak kokoh. Banyak orang terburu-buru “menggunakan
_tools_ ” karena lebih praktikal. Penulis ingin mengajak saudara/i untuk memahami
konsep _machine learning_ secara utuh sebelum memanfaatkan. Ada
perbedaan yang mendasar antara orang yang hanya mampu menggunakan
_tools_ dan mengerti konsep secara utuh.
Buku ini menjelaskan algoritma _machine learning_ dari sudut pandang
agak matematis. Pembaca disa _rank_ an sudah memahami/mengambil setidaknya
mata kuliah statistika, kalkulus, aljabar linear, pengenalan kecerdasan
buatan, dan logika fuzzy. Penulis merasa banyak esensi yang hilang
ketika materi _machine learning_ hanya dijelaskan secara deskriptif karena
itu buku ini ditulis dengan bahasa agak matematis. Walaupun demikian,
VIII Kata Pengantar
penulis berusaha menggunakan notasi matematis seminimal dan sesederhana
mungkin, secukupnya sehingga pembaca mampu mendapatkan intuisi. Saat
membaca buku ini, disa _rank_ an membaca secara runtun. Gaya penulisan buku
inisantai/semiformalagar lebih mudah dipahami, mudah-mudahan tanpa
mengurangi esensi materi.
Buku ini ditulis menggunakan template monograph (LATEX) dari Springer
yang dimodifikasi. Dengan demikian, mungkin ada kesalahan pemenggalan
kata. Tentunya, buku tidak lepas dari kekurangan, misalnya kesalahan tipografi.
Kami sa _rank_ an pembaca untuk membaca secara seksama, termasuk
menginterpretasikan variabel pada persamaan.
Petunjuk Penggunaan
Struktur penyajian buku ini dapat dijadikan acuan sebagai struktur kuliahmachine
_learning_ yang berdurasi satu semester (bab 1 untuk sesi pertama,
dst). Agar dapat memahami materi per bab, bacalah keseluruhan isi
bab secara utuh sebelum mempertanyakan isi materi. Penulis sangat menya _rank_ an
untuk membahas soal latihan sebagai tambahan materi (bisa juga
sebagai PR). Soal latihan ditujukan untuk mengarahkan apa yang harus
dibaca/dipahami lebih lanjut.
Pembaca dipersilahkan menyebarkan ( _share_ ) buku ini untuk alasanNON
KOMERSIAL(pendidikan), tetapidimohon kesadarannya untuk tidak
menyalin atau meniru isi buku ini. Bila ingin memuat konten diktat
ini pada media yang pembaca kelola, dimohon untuk mengontak pengarang
terlebih dahulu. Tidak semua istilah bahasa asing diterjemahkan ke Bahasa
Indonesia supaya makna sebenarnya tidak hilang (atau penulis tidak tahu
versi Bahasa Indonesia yang baku).
Bab lebih awal memuat materi yang relatif lebih “mudah” dipahami
dibanding bab berikutnya. Buku ini memberikan contoh dimulai dari contoh
sederhana (beserta contoh data). Semakin menuju akhir buku, notasi yang
digunakan akan semakin simbolik, beserta contoh yang lebih abstrak. Penulis
sangat menya _rank_ an untukmembaca buku ini secara sekuensial.
Kutipan
Buku ini tergolong _self-published work_ (atau mungkin lebih tepat dikatakan sebagai _draft_ ),
tetapi sudah di- _review_ oleh beberapa orang. Kami yakin para _reviewer_ adalah
orang yang berkompeten. Silahkan merujuk buku ini sesuai dengan
paduan cara merujuk _self-published work_, apabila memang diperbolehkan
untuk merujuk _self-published work_ pada pekerjaan pembaca.
Notasi Penting
Karakter bold kapital merepresentasikan matriks (X,Y,Z). Dimensi matriks
ditulis dengan notasiN×MdimanaNmerepresentasikan banyaknya
baris danMmerepresentasikan banyaknya kolom. Elemen matriks direpresentasikan
olehXi,j,X[i,j], atauxi,juntuk baris ke-ikolom ke-j(penggunaan
akan menyesuaikan konteks pembahasan agar tidak ambigu). Karakter di-
```
Kata Pengantar IX
```
_bold_ merepresentasikan vektor (x). Elemen vektor ke-idirepresentasikan oleh
xiatau x[i]tergantung konteks. Ketika penulis menyebutkan vektor, yang
dimaksud adalah _vektor_ baris( _row vector_, memiliki dimensi 1×N, mengadopsi
notasi Goldberg [1]). Perhatikan, literatur _machine learning_ lainnya
mungkin tidak menggunakan notasi _row vector_ tetapi _column vector_. Kami
harap pembaca mampu beradaptasi. Simbol “·” digunakan untuk melambangkan
operator _dot-product_.
Kumpulan data (atau himpunan) direpresentasikan dengan karakter kapital
(C,Z), dan anggotanya ( _data point_, _data entry_ ) ke-idirepresentasikan
dengan karakterci. Perhatikan, elemen vektor dan anggota himpunan bisa
memiliki notasi yang sama (himpunan dapat direpresentasikan di komputer
sebagai _array_, jadi penggunaan notasi vektor untuk himpunan pada konteks
pembicaraan kita tidaklah salah). Penulis akan menggunakan simbolx[i]sebagai
elemen vektor apabila ambigu. Fungsi dapat direpresentasikan dengan
huruf kapital maupun non-kapitalf(...),E(...),G(...). Ciri fungsi adalah
memiliki parameter! Pada suatu koleksi vektor (himpunan vektor)D, vektor
ke-idirepresentasikan dengandi, dan elemen ke-jdari vektor ke-idirepresentaiskan
dengandi[j],Di,j, atauD[i,j](karena sekumpulan vektor dapat
disusun sebagai matriks).
Karakter non-kapital tanpa _bold_ dan tanpa indeks, seperti (a,b,c,x,y,z),
merepresentasikan _random variable_ (statistik) atau variabel (matematik). Secara
umum, saat _random variable_ memiliki nilai tertentu, dinotasikan dengan
x=X(nilai tertentu dinotasikan dengan huruf kapital), kecuali disebutkan
secara khusus saat pembahasan. Probabilitas direpresentasikan dengan karakter
kapital (P), dengan karakter non-kapital merepresentasikanprobability
density(p). Penulis yakin pembaca dapat menyesuaikan interpretasi simbol
berdasarkan konteks pembahasan. Untuk menginterpretasikan notasi lain, selain
yang diberikan pada paduan ini, mohon menyesuaikan dengan ceritera
pembahasan.
Ucapan Terima Kasih
Terima kasih pada Bapak/Ibu/Saudara/i atas kontribusi pada penulisan buku
ini: Adhiguna Surya Kuncoro, Arief Yudha Satria, Candy Olivia Mawalim,
Chairuni Aulia Nusapati, Genta Indra Winata, Hayyu Luthfi Hanifah, I Gede
Mahendra Darmawiguna, dan Tifani Warnita. Terima kasih pada Natasha
Christabelle Santosa atas desain cover.
Catatan lain
Buku ini adalah _ongoing project_. Versi terakhir dan terakurat dapat diakses
padahttps://wiragotama.github.io/. Buku ini lebih baik dibaca versi full
pdf-nya agar pranala bisa di-klik dan gambar memiliki kualitas terbaik.
Tokyo, Jepang Jan Wira Gotama Putra
|
## 14 Penerapan Pembelajaran Mesin
```
“Leading is not the same as
being the leader. Being the
leader means you hold the
highest rank, either by earning
it, good fortune or navigating
internal politics. Leading,
however, means that others
willingly follow you–not because
they have to, not because they
are paid to, but because they
want to.”
Simon Sinek
```
Bab ini memuat contoh penggunaan _machine learning_ untuk dua permasalahan
praktis yaitu: (1) sistem rekomendasi dan (2) sistem peringkasan
dokumen. Dua domain ini dipilih karena tidak asing (familiar) bagi penulis.
Seperti yang sudah dideskripsikan pada bab-bab sebelumnya, penerapanmachine
_learning_ pada suatu domain membutuhkan pengetahuan/keahlian pada
domain tersebut. Bab ini tidak akan membahas domain secara detail, tetapi secara
abstrak (bertujuan memberikan gambaran/pengenalan). Untuk mengerti
domain yang dibahas secara mendalam, silakan membaca sumber lainnya. Bab
ini akan memuat secara sangat singkat, apa guna _machine learning_ dan pada
contoh kasus seperti apa teknik _machine learning_ diterapkan pada permasalahan
spesifik domain. Tujuan bab ini adalah untuk memberikan gambaran,
bahwa mengetahui _machine learning_ saja mungkin tidak cukup. Sekali lagi
penulis ingin menekankan, pembaca harus mengerti domain aplikasi. Selain
itu, bab ini mengilustrasikan bahwa model _machine learning_ tidak berdiri
sendiri. Artinya, model _machine learning_ bisa jadi hanyalah sebuah modul
(untuk mengeksekusi fungsi tertentu) pada sebuah perangkat lunak.
216 14 Penerapan Pembelajaran Mesin
|
### 7.1 Maximal Margin Classifier
Ingat kembali kedua bab sebelumnya bahwa model klasifikasi mencari suatu
_decision boundary_ untuk memisahkan data pada kelas satu dan kelas lainnya.
Apabila kamu memiliki data berdimensi dua, maka _decision boundary_ yang
kita dapat berupa garis. Pada data tiga dimensi, _decision boundary_ berupa
sebuah bidang ( _plane_ ). Sebagai ilustrasi, lihatlah Gambar 7.1. Secara umum,
konsep bidang pemisah disebut sebagai _hyperplane_. Untuk data berdimensi
F, bidang pemisah kita memiliki dimensiF−1.
Secara matematis, _hyperplane_ didefinisikan pada persamaan 7.1 (dapat
ditulis ulang seperti persamaan 7.2), dimanaxmelambangkan suatu fitur,x
adalah _input_ dalam bentuk _feature vector_ danFmelambangkan banyaknya fitur.
Ingat kembali, ruas kiri pada persamaan adalah bentuk dasar pada model
linear. Dengan demikian, kita mengasumsikan bahwa data dapat dipisahkan
92 7 Support Vector Classifier
```
Gambar 7.1: Ilustrasi _hyperplane_.
```
secara linear.
x 1 w 1 +x 2 w 2 +···+xFwF+b= 0 (7.1)
x·w+b= 0 (7.2)
Untuk permasalahan klasifikasi dua kelas, kita dapat memisahkan keputusan
berdasarkan letak data pada _hyperplane_, misal di atas atau di bawah _hyperplane_ pada
Gambar 7.1. Secara lebih matematis, seperti pada persamaan 7.3
dan 7.4. Konsep ini mirip seperti yang sudah dijelaskan pada bab 5 tentang
melakukan _binary classification_ menggunakan fungsi _sign_ dan _thresholding_.
```
ifx·w+b > 0 ,then classA (7.3)
```
ifx·w+b < 0 ,then classB (7.4)
Apabila kita memang mampu memisahkan data dua kelas secara sempurna
dengan suatu _hyperplane_ ( _linearly separable_ ), pilihan _hyperplane_ yang
dapat kita buat tidaklah satu. Artinya, kita dapat menggeser-geser garis pembatas,
disamping tetap memisahkan data secara sempurna, seperti diilustrasikan
pada Gambar 7.2. _Hyperplane_ terbaik dari beberapa pilihan yang
ada adalah yang memiliki _maximal margin_. Artinya, suatu _hyperplane_ yang
memiliki jarak terjauh terhadap data pada suatu kelas. Dengan demikian,
ada jarak yang besar dari _hyperplane_ dengan data. Ilustrasi diberikan pada
Gambar 7.3. Kita harap, suatu _hyperplane_ yang memiliki _margin_ besar dapat
melakukan klasifikasi dengan baik pada data yang belum kita lihat, karena
kita memberikan _margin_ yang besar untuk suatu data baru masuk ke daerah
kelas masing-masing. Bentuk lingkaran yang memiliki _border_ berwarna hitam
pada Gambar 7.3 menandakan data terluar pada masing-masing kelas, dikenal
```
7.1 Maximal Margin Classifier 93
```
Gambar 7.2: Ilustrasi banyak pilihan _hyperplane_. Garis hitam melambangkan
opsi _hyperplane_ untuk memisahkan data secara sempurna.
sebagai _support vectors_. Garis putus-putus melambangkan garis yang dibentuk
oleh masing-masing _support vectors_ untuk masing-masing kelas ( _margin_ ).
Apabila kita definisikan (simbolkan) kelas pertama dengan _output_ bernilai
1 dan kelas kedua bernilai−1 (ingat kembali materi fungsi _sign_ ), makasupport
vectorsadalah poinxyang memenuhi kriteria pada persamaan 7.5. Dengan
demikian, semua data berlabel 1 dan−1 memenuhi persamaan 7.6, dimanay
melambangkan kategori. Hal inilah yang disebut sebagai _maximal margin_
_classifier_. Kita mencari _support vectors_ yang memberikan _hyperplane_ yang
memiliki _maximal margin_. Lihatlah ilustrasi pada Gambar 7.4!
```
|x·w+b|= 1 (7.5)
```
yi(x·w+b)≥ 1 (7.6)
Misalkan kita ambil satu _support vector_ dari masing-masing kelas. Pada
kelas pertama, ia memenuhixc^1 ·w+b= 1. Pada kelas kedua, ia memenuhi
xc^2 ·w+b=−1. Apabila kita kurangi kedua persamaan tersebut, kita mendapatkan
persamaan 7.7. Persamaan 7.8 memberikan perhitungan _margin_ antara
_support vectors_ dan _hyperplane_ yang memberikan nilai maksimal.
```
w·(xc^1 −xc^2 ) = 2 (7.7)
```
```
w
‖w‖
·(xc^1 −xc^2 ) =
```
#### 2
```
‖w‖
```
#### (7.8)
Sekarang, kita formalisasi _maximal margin classifier_ secara matematis. Objektifnya
adalah memaksimalkan _margin_ (persamaan 7.9) dengan menjaga
setiap _training data_ diklasifikasikan dengan benar (persamaan 7.10).
94 7 Support Vector Classifier
Gambar 7.3: _Maximal Margin Hyperplane_. Bentuk lingkaran yang memiliki
_border_ di- _bold_ berwarna hitam menandakan data terluar pada masing-masing
kelas, dikenal sebagai _support vectors_. Garis putus-putus melambangkan garis
yang dibentuk oleh masing-masing _support vectors_ untuk masing-masing kelas
( _margin_ ).
```
Objective : maximize Margin =
```
#### 2
```
‖w‖
```
#### (7.9)
```
Subject to :yi(xi·w+b)≥ 1 (7.10)
```
Tidak sama dengan _model linear_ yang sudah dijelaskan sebelumnya, kita ingin
mengoptimasi sebuah fungsi sembari memenuhi kendala ( _constraint_ ) dari
fungsi lain. Ini adalah bentuk _integer linear programming_, dan solusi untuk
_maximal margin classifier_ dapat diselesaikan menggunakan _lagrange multiplier_.
Untuk detail penyelesaiannya, silahkan membaca sumber lainnya.
Seperti yang kamu sadari, _maximal margin classifier_ hanya bergantung
pada subset _training data_ yang dipilih sebagai _support vectors_. Dengan demikian,
metode ini sangat sensitif terhadap tiap-tiap observasi. Satu observasi baru
yang menjadi _support vector_ dapat merubah _decision boundary_. Kita kenal
ini sebagai _overfitting_. Ilustrasi permasalahan ini diberikan pada Gambar 7.5.
Selain itu, _maximal margin classifier_ mengasumsikan bahwa data bersifatlinearly
separable, walaupun kebanyakan data tidak bersifat demikian.
```
7.1 Maximal Margin Classifier 95
```
```
Gambar 7.4:Maximal Margin Classifier.
```
Gambar 7.5:Maximal Margin Classifiersangatlah sensitif terhadap perubahan _training_
_data_. Lingkaran berwarna oranye melambangkan _training data_
baru. Akibat kemuculan data baru ini, _decision boundary_ awal (garis berwarna
hitam) berubah secara cukup dramatis (garis berwarna oranye).
96 7 Support Vector Classifier
|
### 7.3 Support Vector Machine
```
Transformasi
```
Gambar 7.7: Ilustrasi transformasi data. Garis berwarna hijau (dashed)
melambangkan _decision boundary_.
Berhubung banyak _decision boundary_ tidak dapat di _model_ kan dengan suatu
bentuk atau persamaan linear, kita harus me _model_ kan _decision boundary_ sebagai
fungsi non-linear. Ekstensi _support vector classifier_ adalahsupport
vector machineyang menggunakan teknik _kernel_. Suatu fungsi _kernel_
mentransformasi data ke ruang ( _space_ atau dimensi) lainnya ( _bias_ anya ke dimensi
lebih tinggi). Data yang ditransformasi ini (pada dimensi lebih tinggi),
kita harapkan dapat dipisahkan dengan fungsi linear. Apabila kita lihat balik
pada dimensi asli, _decision boundary_ pada dimensi yang baru me _model_ kan suatudecision
boundarynon-linear pada dimensi aslinya. Hal ini diilustrasikan
pada Gambar 7.7. Fungsi _kernel_ ini ada banyak, beberapa yang terkenal di-
antaranya:^1
1. Polynomial Kernel (persamaan 7.13)
```
k(xi,xj) = (xi·xj+ 1)d (7.13)
```
2. Radial Basis Function Kernel (persamaan 7.14,σ^2 melambangkan varians)
```
k(x,y) = exp
```
#### (
#### −
```
‖x−y‖^2
2 σ^2
```
#### )
#### (7.14)
Yang membedakan _support vector machine_ dan _support vector classifier_ adalah
mengintegrasikan fungsi _kernel_ pada model.
Sebelum membahas bagaimana fungsi _kernel_ diintegrasikan pada SVM,
kita sedikit bahas kembali _support vector classifier_. Ingat kembalisupport
vector classifier mencari _maximal margin_ (persamaan 7.9) dengan kendala
persamaan 7.11 dan 7.12. Suatu _support vector classifier_ yang memenuhi seluruh
kendala tersebut dapat direpresentasikan sebagai persamaan 7.15 dimana
(^1) https:// _data_ -flair. _training_ /blogs/svm- _kernel_ - _function_ s/
98 7 Support Vector Classifier
x′melambangkan suatu data baru,xiadalah suatu _instance_ pada _training_
_data_ danNadalah banyaknya _training data_. Operasi〈x′,xi〉melambangkan
_inner product_. Cara menghitung _inner product_ dari dua vektor diberikan pada
persamaan 7.16, dimanaFmelambangkan panjangnya vektor. _Inner product_
dapat diinterpretasikan sebagai perhitungan kemiripan dua vektor.
```
f(x′) =β 0 +
```
#### ∑N
```
i=1
```
```
αi〈x′,xi〉 (7.15)
```
```
〈a,b〉=
```
#### ∑F
```
j=1
```
```
ajbj (7.16)
```
Untuk menghitung parameterβdanαpada persamaan 7.15, kita membu-
tuhkan
#### (N
```
2
```
#### )
kombinasi pasangan _instance_ yang ada pada _training data_. Akan
tetapi, pada saat melewatkan suatu _input_ baru pada persamaan tersebut,
kita sebenarnya cukup menghitung seberapa kedekatan (kemiripan) antara
_input_ dan _support vectors_. Hal ini disebabkanαbernilai 0 untuk _instance_
selain _support vectors_, i.e., diatur hanya bernilai _nonzero_ untuk _support vectors_.
Artinya, keputusan klasifikasi bergantung pada pilihan _support vectors_.
Dengan demikian, kita dapat menulis kembali persamaan 7.15 sebagai persamaan
7.17, dimanaSmelambangkan _support vectors_.
```
f(x′) =β 0 +
```
#### ∑
```
xi∈S
```
```
αi〈x′,xi〉 (7.17)
```
Ketika menggunakan fungsi _kernel_, kita menghitung kemiripan ( _inner product_ )
antara dua vektor pada dimensi transformasi. Kita menggantiinner
productmenggunakan suatu fungsi _kernel_, ditulis sebagai persamaan 7.18.
Persamaan inilah yang dikenal sebagai _support vector machine_ (SVM).
Untuk me _model_ kan _non-linear decision boundary_, kita menggunakan fungsi
yang bersifat non-linear sebagai _kernel_.
```
f(x′) =β 0 +
```
#### ∑
```
xi∈S
```
```
αik(x′,xi) (7.18)
```
Untuk memahami SVM lebih dalam, kamu bisa membaca buku karangan
Bishop [8].
|
### Soal Latihan
7.1. Metode _Kernel_
Baca dan jelaskanlah konsep metode kernel yang dijelaskan pada buku
Bishop [8]!
7.2. Fungsi _Kernel_
Jelaskanlah macam-macam fungsi _kernel_ yang sering digunakan untuksupport
vector machine!
7.3. SVM- _rank_
Walau umumnya digunakan untuk permasalahan klasifikasi, SVM juga dapat
diaplikasikan pada permasalahan _ranking_ ( _learning to rank_ ), dikenal sebagai
SVM- _rank_.^2. Permasalahan ini adalah inti dari _search engine_ Jelaskanlah
bagaimana cara kerja SVM- _rank_ !
(^2) https://www.cs.cornell.edu/people/tj/svm_ _light/svm_ _ _rank_.html
|
### 7.5 Tips
Untuk memahami materi yang disampaikan pada bab ini secara lebih dalam,
kami menya _rank_ an kamu untuk mempelajari _optimization theory_ danope _ratio_ n
research (i.e., integer linear programming). Penulis harus mengakui
tidak terlalu familiar dengan teori-teori tersebut. Sejarah dan perkembangansupport
vector machinedapat dibaca pada paper- _paper_ yang diberikan
di pranalahttp://www.svms.org/ _history_.html. Walaupun penjelasan pada
bab ini hanya bersifat “kulit”-nya saja, kami harap pembaca mampu mendapatkan
intuisi.
|
### 7.4 Klasifikasi lebih dari dua kelas
Penjelasan pada bab ini berfokus pada _binary classification_. Memang,maximal
_margin_ classifierdan ekstensinya difokuskan pada permasalahan _binary classification_.
Kita dapat mengekstensinya untuk _multi-class classification_. Ada
dua teknik yang umumnya digunakan, yaitu _one versus one_ danone versus
allseperti yang sudah dijelaskan pada bab 5. Kita dapat mendekomposisi
_classifier_ untuk _multi-label classification_ menjadi beberapa _binary classifiers_,
seperti yang sudah dijelaskan pada bab 5.
```
7.5 Tips 99
```
|
### 7.2 Support Vector Classifier
_Support Vector Classifier_ adalah ekstensi dari _maximal margin classifier_.
Ide utamanya adalah relaksasi kendala pada persamaan 7.10. Sebelumnya,maximal
_margin_ classifiermengasumsikan bahwa data bersifatlinearly
separabledan dipisahkan secara sempurna. Akan tetapi, kenyataan tidaklah
demikian. Ide _support vector classifier_ adalah memperbolehkan beberapa data
diklasifikasikan dengan salah. Kita modifikasi _constraint_ persamaan 7.10 menjadi
persamaan 7.11 untuk memperbolehkan model salah mengklasifikasikan
_data_ dengan parameter kontrol, melambangkan apakah suatu observasi boleh
berada pada ruang yang tidak tepat. Kita juga dapat membatasi seberapa
banyak kesalahan yang dibuat dengan _constraint_ baru yang diberikan pada
persamaan 7.12.
```
Maximize margin,subject to :yi(xi·w+b)≥1(1−i) (7.11)
```
```
i≥0;
```
#### ∑
```
i≤C (7.12)
```
Ilustrasi _support vector classifier_ diberikan pada Gambar 7.6. Disini, kita
sedikit modifikasi definisi _support vectors_ sebagai observasi yang tepat jauh
pada _margin_ atau pada daerah yang tidak sesuai dengan kelasnya [20].
Gambar 7.6: Support Vector Classifier. Lingkaran dengan border di- _bold_
berwarna hitam melambangkan _support vectors_, garis putus-putus melambangkan
_margin_.
Walaupun memperbolehkan beberapa observasi boleh tidak berada pada
ruang yang tepat (berdasarkan _margin_ ), _support vector classifier_ masih memiliki
asumsi bahwa _decision boundary_ berbentuk suatu fungsi linear. Ini adalah
batasan utama model ini.
```
7.3 Support Vector Machine 97
```
|
### 4.2 K- _mean_ s
Pada _supervised learning_ kita mengetahui kelas data untuk setiap _feature vector_,
sedangkan untuk _unsupervised learning_ kita tidak tahu. Tujuan _unsupervised_
_learning_ salah satunya adalah melakukan _clustering_. Yaitu mengelompokkan
_data_ - _data_ dengan karakter mirip. Untuk melakukan pembelajaran
menggunakan _K-means_ [27], kita harus mengikuti langkah-langkah sebagai
berikut:
1. Tentukan jumlah kelompok yang kita inginkan.
2. Inisiasi _centroid_ untuk setiap kelompok (pada bab ini, secara acak). Cen-
troid adalah data yang merepresentasikan suatu kelompok (ibaratnya ke-
tua kelompok).
3. Hitung kedekatan suatu data terhadap _centroid_, kemudian masukkan data
tersebut ke kelompok yang _centroid_ -nya memiliki sifat terdekat dengan
dirinya.
4. Pilih kembali _centroid_ untuk masing-masing kelompok, yaitu dari anggota
kelompok tersebut (semacam memilih ketua yang baru).
5. Ulangi langkah-langkah sebelumnya sampai tidak ada perubahan anggota
untuk semua kelompok.
```
id rich intelligent good looking
1 yes yes yes
2 yes no no
3 yes yes no
4 no no no
5 no yes no
6 no no yes
```
```
Tabel 4.5: Contoh dataset orang kaya
```
Perhatikan Tabel 4.5, kita akan mengelompokkan data pada tabel tersebut
menjadi dua _clusters_ (dua kelompok) yaituk 1 ,k 2 menggunakan algoritma
```
4.2 K- _mean_ s 57
```
```
id perbedaan dengan _centroid_ 1 perbedaan dengan _centroid_ 2 as _sign_ ment
2 2 2 k 1
3 1 3 k 1
4 3 1 k 2
5 2 2 k 1
```
```
Tabel 4.6:As _sign_ ment _K-means_ langkah 1
```
```
id perbedaan dengan _centroid_ 1 perbedaan dengan _centroid_ 2 as _sign_ ment
1 2 3 k 1
3 1 3 k 1
5 3 1 k 2
6 2 2 k 1
```
```
Tabel 4.7:As _sign_ mentK-Means langkah 2
```
_K-means_. Pertama-tama kita inisiasi centroid secara acak,id 1 untukk 1 dan
id 6 untukk 2. Kita hitung kedekatan data lainnya terhadap _centroid_. Untuk
mempermudah contoh, kita hitung perbedaan data satu dan lainnya dengan
menghitung perbedaan nilai atribut (nilai atributnya sama atau tidak).
Apabila perbedaan suatu data terhadap kedua centroid bernilai sama, kita
masukkan ke kelas dengan nomor urut lebih kecil.
Setelah langkah ini, kelompok satu beranggotakan{id 1 ,id 2 ,id 3 ,id 5 }sementara
kelompok dua beranggotakan{id 4 ,id 6 }. Kita pilih kembali centroid
untuk masing-masing kelompok yang mana berasal dari anggota kelompok itu
sendiri. Misal kita pilih secara acak,^1 centroid untuk kelompok pertama adalah
id 2 sementara untuk kelompok kedua adalahid 4. Kita hitung kembali _assignment_ anggota
kelompok yang ilustrasinya dapat dilihat pada Tabel 4.7. Hasil
langkah ke-2 adalah perubahan anggota kelompok,k 1 ={id 1 ,id 2 ,id 3 ,id 5 }
dank 2 ={id 4 ,id 6 }. Anggap pada langkah ke-3 kita memilih kembaliid 2 dan
id 4 sebagai centroid masing-masing kelompok sehingga tidak ada perubahan
keanggotaan.
Bila kamu membaca buku literatur lain, kemungkinan besar akan dijelaskan
bahwa _clustering_ itu memilikihubungan erat denganGaussian
Mixture Model. Secara sederhana,satu _cluster_ (atau satu kelas)sebenarnya
seolah-olah dapat dipisahkan dengan kelas lainnya oleh distribusi
gaussian. Perhatikan Gambar 4.1! Suatu _cluster_ atau kelas, seolah olah “dibungkus”
oleh suatu distribusi gaussian. Distribusi seluruh dataset dapat diaproksimasi
dengan _Gaussian Mixture Model_ (GMM).
Ingat kembali bahwa data memiliki suatu pola (dalam statistik disebut
distribusi), kemudian pada bab 2 telah disebutkan bahwa GMM dipercaya dapat
mengaproksimasi fungsi apapun (silahkan perdalam pengetahuan statistik
(^1) Cara lain memilih akan dijelaskan pada bab 10.
58 4 Algoritma Dasar
```
Gambar 4.1: Ilustrasi hubungan Clustering, kelas, dan Gaussian
```
kamu untuk hal ini). Dengan demikian, _machine learning_ yang mempunyai
salah satu tujuan untuk menemukan pola dataset, memiliki hubungan yang
sangat erat dengan distribusi gaussian karena pola tersebut dapat diaproksimasi
dengan distribusi gaussian.
|
### Soal Latihan
4.1. Data numerik
(a) Carilah suatu contoh dataset numerik.
(b) Pikirkanlah st _rate_ gi untuk mengklasifikasi data numerik pada algoritma
_Naive Bayes_ danK-nearest-neighbor!
4.2. K- _mean_ s, KNN, GMM, EM
Buktikan bahwa K- _mean_ s, K-nearest-neighbor, _Gaussian Mixture Model_, dan
_Expectation Maximization_ Algorithm memiliki hubungan! (apa kesamaan
mereka).
4.3. K- _mean_ s
(a) Cari tahu cara lain untuk memilih _centroid_ pada algoritma K- _mean_ s
(selain cara acak) baik untuk data nominal dan numerik!
(b) Cari tahu cara lain untuk menghitung kedekekatan suatu data dengan
_centroid_ baik untuk data nominal dan numerik! Hint: _euclidian distance_,
_manhattan distance_, _cosine similarity_.
|
### 4.3 K-nearest-neighbor
IdeK-nearest-neighbor(KNN) adalah mengelompokkan data ke kelompok
yang memiliki sifat termirip dengannya [28]. Hal ini sangat mirip denganK _mean_ s.
Bila K- _mean_ s digunakan untuk _clustering_, KNN digunakan untuk
klasifikasi. Algoritma klasifikasi ini disebut juga algoritma malas karena tidak
mempelajari cara mengkategorikan data, melainkan hanya mengingat data
yang sudah ada.^2 Pada subbab 4.2, kita telah mengelompokkan data orang
kaya menjadi dua kelompok.
KNN mencariK _feature vector_ dengan sifat termirip, kemudian mengelompokkan
_data_ baru ke kelompok _feature vector_ tersebut. Sebagai ilustrasi mudah,
kita lakukan klasifikasi algoritma KNN denganK= 3 untuk data baru
{rich=no,intelligent=yes,good looking=yes}. Kita tahu pada subbab
sebelumnya bahwa kelompok satuk 1 ={id 1 ,id 2 ,id 3 ,id 5 }dank 2 ={id 4 ,id 6 },
pada Tabel 4.8. _feature vector_ termirip dimiliki oleh data denganid 1 ,id 5 ,id 6
seperti diilustrasikan pada Tabel 4.8. Kita dapat menggunakan st _rate_ gi untuk
mengurusi permasalahan ini, misalnya memberikan prioritas memasukkan ke
kelompok yang rata-rata perbedaannya lebih kecil.^3 Dengan st _rate_ gi tersebut,
kita mengklasifikasikan data baru ke kelompok pertama.
(^2) https://sebastianraschka.com/faq/docs/lazy-knn.html
(^3) Silahkan eksplorasi cara lain juga!
```
4.3 K-nearest-neighbor 59
```
```
id perbedaan
1 1
2 3
3 3
4 2
5 1
6 1
```
```
Tabel 4.8: Perbedaan data baru vs data orang kaya
```
|
### 4.1 Naive Bayes
_Naive Bayes_ adalah algoritma _supervised learning_ yang sangat sederhana [26].
Idenya mirip dengan probabilitas bayesian pada bab 2. Secara formal, persamaanNaive
Bayesuntuk klasifikasi diberikan pada persamaan 4.1 dimana
ciadalah suatu nilai kelas,Cadalah pilihan kelas (himpunan),tadalah fitur
(satu fitur, bukan _feature vector_ ) danF adalah banyaknya fitur. Kita
memprediksi kelas berdasarkan probabilitas kemunculan nilai fitur pada kelas
tersebut.
Pertama, kita hitung _likelihood_ suatu _feature vector_ diklasifikasikan ke kelas
tertentu berdasarkan bagaiman probabilitas korespondensi fitur-fiturnya
terhadap kelas tersebut (persamaan 4.1). Kemudian, kita normalisasi _likelihood_ semua
kelas untuk mendapatkan probabilitas _class-assignment_ ( _softmax_ –
persamaan 4.2). Akhirnya, kita pilih kelas dengan probabilitas tertinggi (persamaan
4.3).
```
_likelihood_ (ci) =P(ci)
```
#### ∏F
```
f=1
```
```
P(tf|ci) (4.1)
```
54 4 Algoritma Dasar
```
id outlook temperature humidity windy play ( _class_ )
1 sunny hot high false no
2 sunny hot high true no
3 overcast hot high false yes
4 rainy mild high false yes
5 rainy cool normal false yes
6 rainy cool normal true no
7 overcast cool normal true yes
8 sunny mild high false no
9 sunny cool normal false yes
10 rainy mild normal false yes
11 sunny mild normal true yes
12 overcast mild high true yes
13 overcast hot normal false yes
14 rainy mild high true no
```
```
Tabel 4.1: Contoh dataset _play tennis_ (UCI machine learning repository)
```
```
_outlook_ temperature humidity windy play ( _class_ )
yes no yes no yes no yes no yes no
sunny 2 3 hot 2 3 high 3 4 false 6 2 9 5
overcast 4 0 mild 4 2 normal 6 1 true 3 3
rainy 3 2 cool 3 1
```
```
Tabel 4.2: Frekuensi setiap nilai atribut
```
```
_outlook_ temperature humidity windy play ( _class_ )
yes no yes no yes no yes no yes no
sunny 2/9 3/5 hot 2/9 3/5 high 3/9 4/5 false 6/9 2/5 9/14 5/14
overcast 4/9 0/5 mild 4/9 2/5 normal 6/9 1/5 true 3/9 3/5
rainy 3/9 2/5 cool 3/9 1/5
```
```
Tabel 4.3: Probabilitas setiap nilai atribut
```
```
P _assignment_ (ci) =
```
```
_likelihood_ (ci)
∑
cjC _likelihood_ (cj)
```
#### (4.2)
```
cˆi= arg max
ciC
```
```
P _assignment_ (ci) (4.3)
```
Agar mendapatkan gambaran praktis, mari kita bangun model Naive
Bayes untuk Tabel 4.1. Tabel ini disebut sebagai _dataset_, yaitu memuat
_entry_ data (tiap baris disebut sebagai _instance_ ). Kita anggap Tabel 4.1 sebagai _training_
_data_. Untuk menghitung probabilitas, pertama-tama kita
hitung terlebih dahulu frekuensi nilai atribut seperti pada Tabel 4.2, setelah
itu kita bangun model probabilitasnya seperti pada Tabel 4.3.
Untuk menguji kebenaran model yang telah kita bangun, kita menggunakan _testing_
_data_, diberikan pada Tabel 4.4. _testing data_ berisiunseen
exampleyaitu contoh yang tidak ada pada _training data_.
```
4.1 Naive Bayes 55
```
```
id outlook temperature humidity windy play ( _class_ )
1 sunny cool high true no
```
```
Tabel 4.4: Contoh testing data _play tennis_ [7]
```
```
_likelihood_ ( _play=yes_ ) =P(yes)P(sunny|yes)P(cool|yes)P(high|yes)
P(true|yes)
```
```
=
```
#### 9
#### 14
#### ∗
#### 2
#### 9
#### ∗
#### 3
#### 9
#### ∗
#### 3
#### 9
#### ∗
#### 3
#### 9
#### = 0. 0053
```
_likelihood_ ( _play=no_ ) =P(no)P(sunny|no)P(cool|no)P(high|no)
P(true|no)
```
```
=
```
#### 5
#### 14
#### ∗
#### 3
#### 5
#### ∗
#### 1
#### 5
#### ∗
#### 4
#### 5
#### ∗
#### 3
#### 5
#### = 0. 0206
```
P _assignment_ ( _play=yes_ ) =
```
```
_likelihood_ ( _play=yes_ )
_likelihood_ ( _play=yes_ ) + likelihood( _play=no_ )
```
```
=
```
#### 0. 0053
#### 0 .0053 + 0. 0206
#### = 0. 205
```
P _assignment_ ( _play=no_ ) =
_likelihood_ ( _play=no_ )
_likelihood_ ( _play=yes_ ) + likelihood( _play=no_ )
```
```
=
```
#### 0. 0206
#### 0 .0053 + 0. 0206
#### = 0. 795
KarenaP _assignment_ ( _play_ =no)> P _assignment_ ( _play_ =yes) maka diputuskan
bahwa kelas untuk _unseen example_ adalah _play=no_. Proses klasifikasi
untuk data baru sama seperti proses klasifikasi untuk _testing data_, yaitu kita
ingin menebak kelas data. Karena model berhasil menebak kelas pada _training_
_data_ dengan tepat, akurasi model adalah 100% (kebetulan contohnya hanya
ada satu).
Perhatikan! Kamu mungkin berpikir kita dapat langsung menggunakan
_likelihood_ untuk mengklasifikasi, karena probabilitas dengan _likelihood_ terbesar
akan dipilih. Hal ini cukup berbahaya apabila _likelihood_ untuk masingmasing
kelas memiliki jarak yang cukup dekat. Sebagai contoh, menghitung
probabilitas apabila (kasus abstrak) _likelihood_ ={ 0. 70 , 0. 60 }, sehingga probabilitas
kelas menjadi={ 0. 54 , 0. 46 }. Karena perbedaan probabilitas kelas relatif
tidak terlalu besar (contoh ini adalah penyederhanaan), kita mungkin harus
56 4 Algoritma Dasar
berpikir kembali untuk mengklasifikasikan _instance_ ke kelas pertama. Hal ini
berkaitan dengan seberapa yakin kamu mengklasifikasikan suatu sampel ke
kelas tertentu. Perbedaan _likelihood_ yang besar menandakan keyakinan, sementara
perbedaan yang tipis menandakan ketidakyakinan.
Perhatikan, jumlah _likelihood_ mungkin lebih dari 1. Sementara, probabilitas
atau jumlahnya berada pada range [0,1] (0 ≤P ≤1). Pada contoh
sebelumnya, nilai _likelihood_ diubah menjadi bentuk probabilitas dengan
menggunakan teknik _softmax_. Fungsi _softmax_ berbentuk seperti pada persamaan
4.2.
|
### 4.1 Naive Bayes
_Naive Bayes_ adalah algoritma _supervised learning_ yang sangat sederhana [26].
Idenya mirip dengan probabilitas bayesian pada bab 2. Secara formal, persamaanNaive
Bayesuntuk klasifikasi diberikan pada persamaan 4.1 dimana
ciadalah suatu nilai kelas,Cadalah pilihan kelas (himpunan),tadalah fitur
(satu fitur, bukan _feature vector_ ) danF adalah banyaknya fitur. Kita
memprediksi kelas berdasarkan probabilitas kemunculan nilai fitur pada kelas
tersebut.
Pertama, kita hitung _likelihood_ suatu _feature vector_ diklasifikasikan ke kelas
tertentu berdasarkan bagaiman probabilitas korespondensi fitur-fiturnya
terhadap kelas tersebut (persamaan 4.1). Kemudian, kita normalisasi _likelihood_ semua
kelas untuk mendapatkan probabilitas _class-assignment_ ( _softmax_ –
persamaan 4.2). Akhirnya, kita pilih kelas dengan probabilitas tertinggi (persamaan
4.3).
```
_likelihood_ (ci) =P(ci)
```
#### ∏F
```
f=1
```
```
P(tf|ci) (4.1)
```
54 4 Algoritma Dasar
```
id outlook temperature humidity windy play ( _class_ )
1 sunny hot high false no
2 sunny hot high true no
3 overcast hot high false yes
4 rainy mild high false yes
5 rainy cool normal false yes
6 rainy cool normal true no
7 overcast cool normal true yes
8 sunny mild high false no
9 sunny cool normal false yes
10 rainy mild normal false yes
11 sunny mild normal true yes
12 overcast mild high true yes
13 overcast hot normal false yes
14 rainy mild high true no
```
```
Tabel 4.1: Contoh dataset _play tennis_ (UCI machine learning repository)
```
```
_outlook_ temperature humidity windy play ( _class_ )
yes no yes no yes no yes no yes no
sunny 2 3 hot 2 3 high 3 4 false 6 2 9 5
overcast 4 0 mild 4 2 normal 6 1 true 3 3
rainy 3 2 cool 3 1
```
```
Tabel 4.2: Frekuensi setiap nilai atribut
```
```
_outlook_ temperature humidity windy play ( _class_ )
yes no yes no yes no yes no yes no
sunny 2/9 3/5 hot 2/9 3/5 high 3/9 4/5 false 6/9 2/5 9/14 5/14
overcast 4/9 0/5 mild 4/9 2/5 normal 6/9 1/5 true 3/9 3/5
rainy 3/9 2/5 cool 3/9 1/5
```
```
Tabel 4.3: Probabilitas setiap nilai atribut
```
```
P _assignment_ (ci) =
```
```
_likelihood_ (ci)
∑
cjC _likelihood_ (cj)
```
#### (4.2)
```
cˆi= arg max
ciC
```
```
P _assignment_ (ci) (4.3)
```
Agar mendapatkan gambaran praktis, mari kita bangun model Naive
Bayes untuk Tabel 4.1. Tabel ini disebut sebagai _dataset_, yaitu memuat
_entry_ data (tiap baris disebut sebagai _instance_ ). Kita anggap Tabel 4.1 sebagai _training_
_data_. Untuk menghitung probabilitas, pertama-tama kita
hitung terlebih dahulu frekuensi nilai atribut seperti pada Tabel 4.2, setelah
itu kita bangun model probabilitasnya seperti pada Tabel 4.3.
Untuk menguji kebenaran model yang telah kita bangun, kita menggunakan _testing_
_data_, diberikan pada Tabel 4.4. _testing data_ berisiunseen
exampleyaitu contoh yang tidak ada pada _training data_.
```
4.1 Naive Bayes 55
```
```
id outlook temperature humidity windy play ( _class_ )
1 sunny cool high true no
```
```
Tabel 4.4: Contoh testing data _play tennis_ [7]
```
```
_likelihood_ ( _play=yes_ ) =P(yes)P(sunny|yes)P(cool|yes)P(high|yes)
P(true|yes)
```
```
=
```
#### 9
#### 14
#### ∗
#### 2
#### 9
#### ∗
#### 3
#### 9
#### ∗
#### 3
#### 9
#### ∗
#### 3
#### 9
#### = 0. 0053
```
_likelihood_ ( _play=no_ ) =P(no)P(sunny|no)P(cool|no)P(high|no)
P(true|no)
```
```
=
```
#### 5
#### 14
#### ∗
#### 3
#### 5
#### ∗
#### 1
#### 5
#### ∗
#### 4
#### 5
#### ∗
#### 3
#### 5
#### = 0. 0206
```
P _assignment_ ( _play=yes_ ) =
```
```
_likelihood_ ( _play=yes_ )
_likelihood_ ( _play=yes_ ) + likelihood( _play=no_ )
```
```
=
```
#### 0. 0053
#### 0 .0053 + 0. 0206
#### = 0. 205
```
P _assignment_ ( _play=no_ ) =
_likelihood_ ( _play=no_ )
_likelihood_ ( _play=yes_ ) + likelihood( _play=no_ )
```
```
=
```
#### 0. 0206
#### 0 .0053 + 0. 0206
#### = 0. 795
KarenaP _assignment_ ( _play_ =no)> P _assignment_ ( _play_ =yes) maka diputuskan
bahwa kelas untuk _unseen example_ adalah _play=no_. Proses klasifikasi
untuk data baru sama seperti proses klasifikasi untuk _testing data_, yaitu kita
ingin menebak kelas data. Karena model berhasil menebak kelas pada _training_
_data_ dengan tepat, akurasi model adalah 100% (kebetulan contohnya hanya
ada satu).
Perhatikan! Kamu mungkin berpikir kita dapat langsung menggunakan
_likelihood_ untuk mengklasifikasi, karena probabilitas dengan _likelihood_ terbesar
akan dipilih. Hal ini cukup berbahaya apabila _likelihood_ untuk masingmasing
kelas memiliki jarak yang cukup dekat. Sebagai contoh, menghitung
probabilitas apabila (kasus abstrak) _likelihood_ ={ 0. 70 , 0. 60 }, sehingga probabilitas
kelas menjadi={ 0. 54 , 0. 46 }. Karena perbedaan probabilitas kelas relatif
tidak terlalu besar (contoh ini adalah penyederhanaan), kita mungkin harus
56 4 Algoritma Dasar
berpikir kembali untuk mengklasifikasikan _instance_ ke kelas pertama. Hal ini
berkaitan dengan seberapa yakin kamu mengklasifikasikan suatu sampel ke
kelas tertentu. Perbedaan _likelihood_ yang besar menandakan keyakinan, sementara
perbedaan yang tipis menandakan ketidakyakinan.
Perhatikan, jumlah _likelihood_ mungkin lebih dari 1. Sementara, probabilitas
atau jumlahnya berada pada range [0,1] (0 ≤P ≤1). Pada contoh
sebelumnya, nilai _likelihood_ diubah menjadi bentuk probabilitas dengan
menggunakan teknik _softmax_. Fungsi _softmax_ berbentuk seperti pada persamaan
4.2.
|
### 3.6 Classification, Association, Clustering
Padasupervsied learning, kita memprediksi kelas berdasarkan _feature vector_
yang merepresentasikan suatu sampel ( _data_ /observasi). _Feature vector_ bisa
diibaratkan sebagai sifat-sifat atau keadaan yang diasosiasikan dengan kelas.
Pada _supervised learning_, setiap _feature vector_ berkorespondisi dengan kelas
tertentu. Mencari kelas yang berkorespondensi terhadap suatu _input_ disebutklasifikasi( _classification_ ).
Contoh klasifikasi adalah mengkategorikan
gambar buah (e.g. apel, jeruk, dsb). Sementara itu, apabila kita ingin mencari
hubungan antara satu atribut dan atribut lainnya, disebutassociation. Sebagai
contoh pada Tabel 3.1, apabila _outlook=sunny_, maka sebagian besar
_humidity=high_. Di lain pihak, pada _unsupervised learning_ tidak ada kelas
yang berkorespondensi; kita mengelompokkan data dengan sifat-sifat yang
mirip, disebut _clustering_. Contoh _clustering_ adalah pengelompokkan barang
di supermarket. Perlu kamu catat bahwa _unsupervised learning_ 6 = _clustering_.
_Clustering_ adalah salah satu _task_ pada _unsupervised learning_.
Pada Tabel 3.1, hanya ada dua kelas, klasifikasi data ini disebut binary
_classification_. Apabila kelas klasifikasi lebih dari dua ( _mutually exclusive_ ),
disebut _multi-class classification_. Apabila kelas-kelas tersebut
tidak bersifat _mutually exclusive_, maka kita melakukan _multi-label classification_.
Mohon bedakan antara _multi-label classification_ danmultilevel/ _hierarchical_
_classification_. Pada _multi-level/hierarchical classification_,
pertama-tama kita melakukan klasifikasi untuk suatu kelas generik, lalu
(^5) https://en.wikipedia.org/wiki/Feature_selection
(^6) [http://scikit-learn.org/stable/modules/feature_selection.html](http://scikit-learn.org/stable/modules/feature_selection.html)
46 3 Data Analytics
dilanjutkan mengklasifikan data ke kelas yang lebih spesifik. Contohmultilevel
_classification_ adalah _kingdom_ (biologi), pertama diklasifikasikan ke _kingdom_
animalia, lalu lebih spesifiknya ke _phylum Vertebrata_, dst.Multi-label
_classification_ hanya proses klasifikasi ke dalam banyak “kelas” tanpa tinjauan
hirarkis.
_Multi-class classification_ yang telah dijelaskan sebelumnya disebut juga
sebagai _hard classification_, artinya apabila data diklasifikasikan ke kelas tertentu,
maka tidak mungkin data berada di kelas lainnya (ya atau tidak).
_Multi-label classification_ bersifat lebih _soft_, karena dapat mengklasifikasikan
ke beberapa kelas, misal data X memiliki masuk ke kategori kelas A, B dan
C sekaligus (dengan nilai probabilitas masing-masing).
|
### 3.3 Ruang Konsep
Dengan data yang diberikan, kita ingin melakukan generalisasi aturan/ konsep
yang sesuai dengan data. Hal ini disebut sebagai _inductive learning_. Cara
paling sederhana untuk _inductive learning_ adalah mengenumerasi seluruh kemungkinan
kombinasi nilai sebagai _rule_, kemudian mengeleminasi _rule_ yang
tidak cocok dengan contoh. Metode ini disebut _list-then-eleminate_. Silahkan
baca buku Tom Mitchell [4] untuk penjelasakn lebih rinci. Kemungkinan kombinasi
nilai ini disebut sebagai ruang konsep ( _concept space_ ). Sebagai contoh
pada Tabel 3.1 himpunan nilai masing-masing atribut yaitu:
- outlook={sunny,overcast,rainy}
- temperature={hot,mild,cold}
- humidity={high, _norm_ al}
- windy={true,false}
- play={yes,no}
sehingga terdapat 3× 3 × 2 × 2 ×2 = 72 kemungkinan kombinasi. Tentunya kita
tidak mungkin mengenumerasi seluruh kemungkinan kombinasi nilai karena
secara praktikal, atribut yang digunakan banyak. Terlebih lagi, apabila mengenumerasi
kombinasi atribut bertipe numerik.
Ada algoritma lain yang mendaftar “seluruh kemungkinan kombinasi”
bernama _candidate-elemination algorithm_ yang lebih efisien dibandinglistthen-eliminate.
Akan tetapi, algoritma ini _computationally expensive_ secara
praktikal, dalam artian memiliki kompleksitas yang besar dan tidak bisa
menyelesaikan permasalahan nyata. Kamu dapat membaca algoritma ini
pada buku Tom Mitchell [4] juga. Selain _inductive learning_, kita juga dapat
melakukan _deductive learning_ yaitu melakukan inferensi dari hal general menjadi
lebih spesifik. Walau demikian, secara praktis kita sebenarnya melakukan
_inductive learning_.
|
### 3.2 Nilai Atribut dan Transformasi
Perhatikan Tabel 3.1 yang merupakan contoh _dataset_ pada _machine learning_.
_Dataset_ adalah kumpulan sampel. Seorang anak ingin bermain tenis, tetapi
keputusannya untuk bermain tenis ( _play_ ) tergantung pada empat variabel
{ _outlook_, temperature, humidity, windy}. Keempat variabel ini disebutfitur.
Setiap fitur memilikiatributnilai dengantipe datadan _range_ tertentu.
Keputusan untuk bermain ( _play_ ) disebut sebagai label atau kelas ( _class_ ).
Pada bab 1 kamu telah diperkenalkan _supervised learning_ dan _unsupervised_
_learning_. Pada _supervised learning_, kita ingin mengklasifikasikan apakah seorang
anak akan bermain atau tidak, diberikan fitur-fitur yang memuat kondisi
observasi. Pada _unsupervised learning_, informasi kolom _play_ tidak diberikan,
kita harus mengelompokkan data tersebut sesuai dengan fitur-fiturnya (contoh
lebih nyata diberikan pada bab 4).
Dari segi data statistik, terdapat beberapa tipe atribut [23]:
1.Nominal. Nilai atribut bertipe nominal tersusun atas simbol-simbol yang
berbeda, yaitu suatu himpunan terbatas. Sebagai contoh, fitur _outlook_
pada Tabel 3.1 memiliki tipe datanominalyaitu nilainya tersusun oleh
himpunan{sunny, overcast, rainy}. Pada tipe nominal, tidak ada urutan
ataupun jarak antar atribut. Tipe ini sering juga disebutkategorialatau
enumerasi. Secara umum, tipe _output_ pada _supervised learning_ adalah
_data_ nominal.
```
2.Ordinal. Nilai ordinal memiliki urutan, sebagai contoh 4> 2 >1. Tetapi
jarak antar suatu tipe dan nilai lainnya tidak harus selalu sama, seperti
4 − 26 = 2−1. Atribut ordinal kadang disebut sebagainumerikataukon-
tinu.
```
```
3.Interval. Tipe interval memiliki urutan dan _range_ nilai yang sama. Sebagai
contoh 1− 5 , 6 − 10 ,dst. Kita dapat mentransformasikan/ mengkonversi
nilai numerik menjadi nominal dengan cara merubahnya menjadi
```
42 3 Data Analytics
```
id outlook temperature humidity windy play ( _class_ )
1 sunny hot high false no
2 sunny hot high true no
3 overcast hot high false yes
4 rainy mild high false yes
5 rainy cool normal false yes
6 rainy cool normal true no
7 overcast cool normal true yes
8 sunny mild high false no
9 sunny cool normal false yes
10 rainy mild normal false yes
11 sunny mild normal true yes
12 overcast mild high true yes
13 overcast hot normal false yes
14 rainy mild high true no
```
```
Tabel 3.1: Contoh dataset _play tennis_ (UCI machine learning repository).
```
```
interval terlebih dahulu. Lalu, kita dapat memberikan nama (simbol) untuk
masing-masing interval. Misalkan nilai numerik dengan _range_ 1 − 100
dibagi menjadi 5 kategori dengan masing-masing interval adalah{ 1 −
20 , 21 − 40 ,..., 81 − 100 }. Setiap interval kita beri nama, misal interval
81 −100 diberi namanilai A, interval 61−80 diberi namanilai B.
```
```
4.Ratio. Tipe _ratio_ (rasio) didefinisikan sebagai perbandingan antara suatu
nilai dengan nilai lainnya, misalkan massa jenis (fisika). Pada tipe _ratio_
terdapat _absolute zero_ (semacam _ground truth_ ) yang menjadi acuan, dan
_absolute zero_ ini memiliki makna tertentu.
```
Secara umum, data pada _machine learning_ adalah nominal atau numerik
(ordinal). Variabel yang kita prediksi yaitu _play_ disebutkelas/ _class_ /label.
Untuk setiap baris pada Tabel 3.1, baris kumpulan nilai variabel non-kelas
disebut _vektor_ fitur/ _feature vector_. Contohnya pada Tabel 3.1,feature
vector-nya untuk data denganid= 4 adalahx 4 ={ _outlook=rainy_, temperature=mild,
_humidity=high_, windy=false}. _Feature vector_ adalah representasi
dari suatu observasi/ _data_. Pada _machine learning_, kita melakukan operasi terhadap
_data_ pada representasi _feature vector_ -nya. Kami serahkan pada pembaca
untuk mencari contoh dataset dengan tipe numerik sebagai pekerjaan
rumah.^2
(^2) https://www.cs.waikato.ac.nz/ml/weka/ _dataset_ s.html
```
3.4 Linear Separability 43
```
|
### 3.7 Mengukur Kinerja
Pada bab 1, sudah dijelaskan bahwa kita harus mengukur kinerja model dengan
cara yang kuantitatif. Pada saat proses latihan, kita ingin model mengoptimalkan
suatu nilai _utility function_, misal meminimalkan nilai _error_ atau
_entropy_. Pada saat latihan, model pembelajaran mesin dapat mengoptimalkan
_utility function_ yang berbeda-beda (tergantung algoritma).
Kita juga dapat mengevaluasi model secara eksternal dengan melewatkan
_data_ pada model (umumnya _validation_ dan _testing data_ ), kemudian mengevaluasi
prediksi final model tersebut dengan ukuran _performance measure_.Performance
measuredapat mengukur kinerja model yang dikonstruksi oleh algoritma
yang berbeda (akan lebih jelas sembari kamu membaca buku ini).
Sebagai contoh, kamu dapat membandingkan kinerja prediksi model dengan
menggunakan metrik seperti akurasi, presisi, _recall_, F1-measure, BLEU [24],
ROUGE [25], _intra-cluster similarity_, dsb. Masing-masing _performance measure_ mengukur
hal yang berbeda. Perlu kamu ketahui bahwa memilih ukuran
kinerja tergantung pada domain permasalahan. Misalkan pada translasi
otomatis, peneliti menggunakan ukuran BLEU; pada peringkasan dokumen,
menggunakan ROUGE. Sementara itu, pada _information retrival_ /sistem temu
balik informasi menggunaan presisi, _recall_, F1-measure, atau _mean_ average
precision (MAP). Pada domain klasifikasi gambar, menggunakan akurasi.
Masing-masing _performance measure_ dapat memiliki karakteristik nilai optimal
yang berbeda. Kamu harus mengerti domain permasalahan untuk
mengerti cara mencapai titik optimal. Sebagai pengantar, diktat ini tidak dapat
membahas seluruh domain. Dengan demikian, kamu harus membaca lebih
lanjut literatur spesifik domain, misal buku pemrosesan bahasa alami atau
sistem temu balik informasi, dsb. Sebagai contoh, untuk permasalahan klasifikasi,
akurasi sering digunakan. Akurasi didefinisikan pada persamaan 3.1.
Buku ini akan membahas _performance measure_ dengan lebih lengkap pada
bab 9.
```
akurasi =
```
```
# _input_ diklasifikasikan dengan benar
banyaknya data
```
#### (3.1)
```
3.8 Evaluasi Model 47
```
|
### Soal Latihan
3.1. Konversi atribut
Sebutkan dan jelaskan macam-macam cara untuk mengkonversi atribut! Sebagai
contoh, numerik-nominal dan nominal-numerik.
3.2. Transformasi data
Sebutkan dan jelaskan macam-macam cara transformasi data (e.g. merubah
_non-linearly separable_ menjadi _linearly separable_ )
3.3. Seleksi fitur
Bacalah algoritma seleksi fitur pada _library_ sklearn. Jelaskan alasan ( _rationale_ )
dibalik penggunaan tiap algoritma yang ada!
3.4. Inductive Learning
Jelaskanlah algoritma _list-then-eliminate_ dan _candidate-elimination_ !
3.5. Tahapan analisis
Agar mampu memahami tahapan analisis data dan pembelajaran mesin secara
lebih praktikal, kerjakanlah tutorial berikut!
https://scikit-learn.org/stable/tutorial/basic/tutorial.html
|
### 3.1 Pengenalan Data Analytics
Secara umum, subbab ini adalah ringkasan dari buku Jeff Leek [22]. Untuk
detailnya, kamu dapat membaca buku tersebut secara langsung. Penulis
merekomendasikan buku tersebut karena ringkas dan mudah dipahami bahkan
oleh pemula.
Kita tahu di dunia ini ada banyak masalah. Masalah adalah ketika tujuan
yang diinginkan tidak tercapai ( _current state_ bukanlah _desired state_ ). Agar
_current state_ menjadi _desired state_, kita melakukan kegiatan yang disebut
penyelesaian masalah ( _problem solving_ ). Tiap bidang (domain) mendefinisikan
permasalahan secara berbeda. Oleh karena itu, mengetahui teknikmachine
_learning_ tanpa mengetahui domain aplikasi adalah sesuatu yang kurang baik
(semacam buta). Kamu memiliki ilmu, tetapi tidak tahu ilmunya mau digunakan
untuk apa. Contohnya, bidang keilmuan pemrosesan bahasa alami
( _natural language processing_ ) menggunakan _machine learning_ untuk mengklasifikasikan
teks; bidang keilmuan pemrosesan suara menggunakanmachine
40 3 Data Analytics
_learning_ untuk mentranskripsikan suara manusia menjadi teks. Tiap bidang
merepresentasikan permasalahan ke dalam formulasi yang berbeda. Bisa jadi
bentuk komputasi (representasi) pada bidang satu berbeda dengan bidang
lainnya. Hal ini perlu kamu ingat karena interpretasi representasi sangat
bergantung pada konteks permasalahan (domain). Buku ini adalah pengenalan
teknik yang bersifat umum.
Seperti yang sudah dijelaskan pada bab-bab sebelumnya. _Machine learning_ adalah
_infer_ ensi berdasarkan data. _Raw data_ atau data mentah adalah
sekumpulan fakta ( _record_, _event_ ) yang kemungkinan besar tidak memberikan
penjelasan apapun. Sama halnya dengan kebanyakan data di dunia nyata,raw
_data_ bersifat tidak rapih, misalnya mengandung _missing value_, i.e., ada data
yang tidak memiliki label padahal data lainnya memiliki label (ingat kembali
materi bab 1). Agar mampu menganalisis _raw data_ menggunakan teknik
_machine learning_, pertama-tama kita harus merapikan data sesuai dengan
format yang kita inginkan ( _dataset_ ). Kemudian, mencari fitur-fitur yang dapat
merepresentasikan data. Kedua kegiatan ini secara umum dikenal dengan
istilah _pre-processing_. Setelah _pre-processing_, kita menggunakan teknik-teknik
yang ada untuk menemukan pola-pola yang ada di data (membangun model).
Pada beberapa bidang, _pre-processing_ adalah tahapan yang memakan waktu
paling banyak pada eksperimen _machine learning_, sedangkan proses melatih
_model_ mungkin memakan waktu jauh lebih singkat.
Dalam komunitas peneliti basis data, dipercaya bahwa data memiliki sangat
banyak relasi yang mungkin tidak bisa dihitung. Teknik _machine learning_
hanya mampu mengeksplorasi sebagian relasi yang banyak itu. Lalu, kita analisis
informasi yang kita dapatkan menjadi pengetahuan yang digunakan untuk
memecahkan permasalahan atau membuat keputusan.
Setelah kita menganalisis data dan mendapatkan pengetahuan baru, pengetahuan
yang kita temukan dari data pada umumnya dipresentasikan (konferensi,
rapat, dsb). Hal umum yang dipaparkan saat presentasi, yaitu:
```
1. _Performance measure_. Seberapa “bagus” model atau metode yang kamu
usulkan, dibandingkan menggunakan model yang sudah ada.Performance
measure biasa disajikan dalam bentuk tabel. Perhatikan, mengatakan
_model_ /metode kamu “lebih bagus” adalah suatu hal subjektif, untuk itu
gunakanlah metode kuantitatif, seperti _p-value_ dalam statistik (hypothesis
_testing_ )^1 untuk mengatakan bahwa memang metode kamu lebih baik
(berbeda) dari _baseline_.
```
2. Tren. Bagaimana pola-pola umum yang ada di data, sesuai dengan tujuan
analisis (permasalahan). Biasa disajikan dalam bentuk teks, kurva, atau
grafik.
```
3. _Outlier_. Sajikan data- _data_ yang “jarang” atau tidak sesuai dengan tren
yang ada. Apa beda sifat data _outlier_ ini dibanding data pada tren? Kamu
```
(^1) https://onlinecourses.science.psu.edu/statprogram/ _node_ /138
```
3.2 Nilai Atribut dan Transformasi 41
```
```
harus menganalisis hal ini untuk meningkatkan _performance measure_ pada
penelitian atau analisis men _data_ ng. Apakah _outlier_ ini penting untuk diurus
atau bisa dipandang sebelah mata tanpa membahayakan keputusan/sistem?
Tidak jarang kamu mendapat inspirasi untuk meningkatkan
kinerja sistem setelah menganalisis _outlier_.
```
Langkah kerja yang dijelaskan ini adalah pekerjaan rutin _data scientist_.
Penulis ingin menekankan sekali lagi, bahwa memahami _machine learning_
saja tidak cukup,kamu harus memahami domain permasalahanagar
mampu melakukan analisis dengan tepat. Terdapat banyak hal yang hanya
mampu kamu pahami dari menganalisis data, apabila kamu mengerti domain
aplikasi.
|
### 3.4 Linear Separability
```
id humidity windy swim ( _class_ )
1 high high yes
2 normal normal no
```
```
Tabel 3.2: Contoh dataset _linearly separable_.
```
Perhatikan Tabel 3.2. Data pada tabel tersebut kita sebut _linearly separable_.
Sederhananya, untuk suatu nilai tertentu, fitur hanya berkorespondensi
dengan kelas tertentu. Ambil contoh pada Tabel 3.2, saat _humidity=high_ maka
44 3 Data Analytics
swim=yes. Secara geometris, bila kita proyeksikan _feature vector_ ke suatu ruang
dimensi, memisahkan kelas satu dan kelas lainnya dapat diperoleh dengan
cara menciptakan garis linier ( _linear line_ )–secara lebih umum, menggunakan _hyperplane_.^3
Ilustrasi dapat dilihat pada Gambar 3.1. Sementara pada
Tabel 3.1, bila kita hanya melihat fitur _humidity_ saja, ketika _humidity=high_
bisa jadi _play=yes_ atau _play=no_. Kasus ini disebut _non-linearly separable_.
Hidup kita tentu akan mudah apabila seluruh data bersifat _linearly separable_,
sayangnya kebanyakan data yang ada bersifat _non-linearly separable_.
```
Gambar 3.1:LinearlyvsNon-Linearly Separable.
```
Untuk memudahkan proses pada data _non-linearly separable_, kita pertamatama
mentransformasikan data menjadi _linearly-separable_. Kita dapat menggunakan
teknik transformasi data menggunakan _kernel function_ sepertiradial
basis function.^4 Pada umumnya, _kernel function_ mentransformasi data menjadi
lebih tinggi (semacam menambah fitur). Misal dari data yang memiliki
dua fitur, ditransformasi menjadi memiliki tiga fitur. Akan tetapi, hal ini
tidak praktikal untuk banyak kasus (dijelaskan pada bab 11). Cara lainnya
adalah memisahkan data menggunakan model non-linear, contoh:artificial
_neural network_. Hal ini penting dipahami karena data yang bersifatlinearly
separablemudah dipisahkan satu sama lain sehingga mudah untuk melakukan
_classification_ atau _clustering_.
|
### 3.8 Evaluasi Model
Ada beberapa hal yang perlu kamu catat tentang proses evaluasi suatu model
pembelajaran mesin:
```
1. _Data splitting_. Seperti yang sudah dijelaskan pada subbab 1.5, pada
umumnya kita memiliki _training_, _validation/validation_, dan _testing data_.
Mesin dilatih menggunakan _training data_, saat proses _training_,performance
measurediukur berdasarkan kemampuan mengenali/ mengeneralisasi _validation_
_data_. Perlu diketahui, _performance measure_ diukur menggunakan _validation_
_data_ untuk menghindari _overfitting_ dan _underfitting_.
Setelah selesai dilatih, maka model hasil pembelajaran dievaluasi dengan
_testing data_. _Training_, _validation_, dan _testing_ data tersusun oleh data yang
independen satu sama lain (tidak beririsan) untuk memastikan model
yang dihasilkan memiliki generalisasi cukup baik.
2. _Overfitting dan Underfitting_. _Overfitting_ adalah keadaan ketika model
memiliki kinerja baik hanya untuk _training data/seen examples_ tetapi
tidak memiliki kinerja baik untuk _unseen examples_.Underfttingadalah
keadaan ketika model memiliki kinerja buruk baik untuk _training data_
dan _unseen examples_. Hal ini akan dibahas lebih detil pada subbab 5.8.
3. _Cross validation_. _Cross validation_ adalah teknik untuk menganalisis
apakah suatu model memiliki generalisasi yang baik (mampu memiliki
kinerja yang baik pada _unseen examples_ ). Seperti yang kamu ketahui,
kita dapat membagi data menjadi _training_, _validation_, dan _testing data_.
Saat proses _training_, kita latih model dengan _training data_ serta dievaluasi
menggunakan _validation data_. Teknik _cross validation_ bekerja dengan
prinsip yang sama, yaitu membagi sampel asli menjadi beberapa subsampel
dengan partisi sebanyakK(K- _fold_ ). Ilustrasi diberikan oleh Gambar
3.2. Persegi panjang melambangkan suatu sampel. Saat proses _training_,
kita bagi data menjadi _training data_ dan _test data_ (i.e., _validation_
_data_ ). Hal ini diulang sebanyakKkali. Kita evaluasi kemampuan generalisasi
_model_ dengan merata-ratakan kinerja pada tiap iterasi. Setelah itu,
_model_ dengan kinerja terbaik (pada iterasi teretentu) digunakan lebih lanjut
untuk proses _testing_ atau dipakai secara praktis. Perlu diperhatikan,
setiap subsampel sebaiknya memiliki distribusi yang sama dengan sampel
aslinya (keseluruhan sampel); i.e., pada contoh, proporsi warna biru dan
merah adalah sama tiap partisi tiap iterasi. Konsep tersebut lebih dikenal
dengan _stratified sampling_.^7
```
(^7) https://en.wikipedia.org/wiki/Stratified_ _sampling_
48 3 Data Analytics
Gambar 3.2: Ilustrasi 3- _fold_ cross validation. Warna merah dan biru melambangkan
sampel ( _instance_ ) yang tergolong ke dua kelas berbeda.
|
### 3.10 Tahapan Analisis
Bagian ini adalah ringkasan bab ini. Untuk menganalisis data, terdapat
langkah yang perlu kamu perhatikan
1. Memutuskan tujuan analisis data ( _defining goal_ )
2. Mendapatkan data
3. Merapihkan data
4. Merepresentasikan data sebagai _feature vector_
5. Melakukan transformasi dan/atau _feature selection_ (mengurasi dimensi
feature vector)
6. Melatih model ( _training_ ) dan menganlisis kinerjanya pada _validation_ (de-
velopment) _data_.
7. Melakukan _testing_ dan analisis model baik secara kuantitatif dan kuali-
tatif
8. Menyajikan data (presentasi)
Saat ini, mungkin kamu merasa bab ini kurang berguna. Hal ini disebabkan
karena konsep yang dipaparkan oleh bab ini bersifat _high-level_. Kamu mungkin
harus membaca bab ini kembali setelah selesai membaca seluruh buku agar
mendapatkan pemahaman lebih mendalam.
|
### 3.5 Seleksi Fitur
Pada subbab sebelumnya, telah dijelaskan bahwa kita dapat mentransformasi
_data_ _non-linearly separable_ menjadi _linearly separable_ dengan cara menam-
(^3) https://en.wikipedia.org/wiki/ _Hyperplane_
(^4) Silakan baca teknik transformasi lebih lanjut pada literatur lain.
```
3.6 Classification, Association, Clustering 45
```
bah dimensi data. Pada bab ini, penulis akan menjelaskan justru kebalikannya!
Pada permasalahan praktis, kita seringkali menggunakan banyak fitur
( _computationally expensive_ ). Kita ingin menyederhanakan fitur-fitur yang digunakan,
misalkan dengan memilih subset fitur awal, atas dasar beberapa
alasan [22, 4]:^5
1. Menyederhanakan data atau model agar lebih mudah dianalisis.
2. Mengurangi waktu _training_ (mengurangi kompleksitas model dan infer-
ensi).
3. Menghindari _curse of dimensionality_. Hal ini dijelaskan lebih lanjut pada
bab 12.
4. Menghapus fitur yang tidak informatif.
5. Meningkatkan generalisasi dengan mengurangi _overfitting_.
Salah satu contoh cara seleksi fitur adalah menghapus atribut yang memiliki _variance_
bernilai 0. Berdasarkan _information theory_ atau _entropy_, fitur
ini tidak memiliki nilai informasi yang tinggi. Dengan kata lain, atribut yang
tidak dapat membedakan satu kelas dan lain bersifat tidak informatif. Kamu
dapat membaca beberapa contoh algoritma seleksi fitur pada library sklearn.^6
|
### 3.9 Kategori Jenis Algoritma
Algoritma pembelajaran mesin dapat dibagi menjadi beberapa kategori. Dari
sudut pandang apakah algoritma memiliki parameter yang harus dioptimasi,
dapat dibagi menjadi:^8
1. Parametrik. Pada kelompok ini, kita mereduksi permasalahan sebagai
optimisasi parameter. Kita mengasumsikan permasalahan dapat dilam-
bangkan oleh fungsi dengan bentuk tertentu (e.g., linier, polinomial, dsb).
Contoh kelompok ini adalah model linier.
2. Non parametrik. Pada kelompok ini, kita tidak mengasumsikan per-
masalahan dapat dilambangkan oleh fungsi dengan bentuk tertentu. Con-
toh kelompok ini adalah _Naive Bayes_, _decision tree_ (ID3) danK-Nearest
Neighbors.
Dari sudut pandang lainnya, jenis algoritma dapat dibagi menjadi:
1. Model linear, contoh regresi linear, regresi logistik, _support vector_ ma-
chine.
2. Model probabilistik, contoh _Naive Bayes_, _hidden markov model_.
3. Model non-linear, yaitu ( _typically_ ) _artificial neural network_.
Selain kedua skema pengkategorian ini, terdapat skema pengkategorian lain
(silahkan eksplorasi sendiri).
(^8) Artificial Neural Networkdapat dikategorikan ke dalam keduanya.
```
3.10 Tahapan Analisis 49
```
|
### 5.4 Multi- _class_ Classification
Subbab ini akan membahas tentang _multi-class classification_, dimana terdapat
lebih dari dua kemungkinan kelas. Terdapat himpunan kelasCberanggotakan
{c 1 ,c 2 ,...,cK}. Untuk suatu data dengan representasi _feature vector_ -nya, kita
ingin mencari tahu kelas yang berkorespondesi untuk data tersebut. Contoh
```
5.4 Multi- _class_ Classification 67
```
permasalahan ini adalah mengklasifikasi gambar untuk tiga kelas: _apel_,jeruk,
atau _mangga_. Cara sederhana adalah memiliki tiga buah vektor parameter
dan _bias_ berbeda,w _apel_,wjeruk,w _mangga_, dan _bias_ b{ _apel_,jeruk, _mangga_ }. Untuk
menentukan suatu data masuk ke kelas mana, kita dapat memprediksi skor
tertinggi yang diberikan oleh operasi _feature vector_ terhadap masing-masing
_vektor_ parameter. Konsep matematisnya diberikan pada persamaan 5.12, dimana
ˆcadalah kelas terpilih (keputusan), yaitu kelas yang memiliki nilai tertinggi.Cmelambangkan
himpunan kelas.
```
c _apel_ =x·w _apel_ +b _apel_
cjeruk=x·wjeruk+bjeruk
c _mangga_ =x·w _mangga_ +b _mangga_
ˆc= arg max
ci∈C
```
```
(ci)
```
#### (5.12)
Tiga set parameter wci dapat disusun sedemikian rupa sebagai matriks
W∈Rd×^3 , dimanadadalah dimensi _feature vector_ (x∈R^1 ×d). Demikian
pula kita dapat susun bias menjadi vektorb∈R^1 ×^3 berdimensi tiga. Dengan
demikian, persamaan 5.12 dapat ditulis kembali sebagai persamaan 5.13, dimanacadalah
_vektor_ yang memuat nilai fungsi terhadap seluruh kelas. Kita
memprediksi kelas berdasarkan indeks elemencyang memiliki nilai terbesar
(persamaan 5.14). Analogika, seperti memilih kelas dengan nilai _likelihood_
tertinggi.
```
c=f(x) =x·W+b (5.13)
```
```
ˆc= arg max
ci∈c
```
```
(ci) (5.14)
```
Seperti yang diceritakan pada subbab berikutnya, kita mungkin juga tertarik
dengan probabilitas masing-masing kelas, bukan hanya _likelihood_ -nya.
Kita dapat menggunakan fungsi _softmax_ ^3 untuk hal ini. Fungsi _softmax_ mentransformasicagar
jumlah semua nilainya berada pada range [0,1]. Dengan
itu,cdapat diinterpretasikan sebagai distribusi probabilitas. Konsep ini dituangkan
pada persamaan 5.15, dimanaciadalah elemen vektor ke-i, melambangkan
probabilitas masuk ke kelas ke-i.
```
ci=
e(x·W+b)[i]
∑
je
```
```
(x·W+b)[j] (5.15)
```
Karena _output_ fungsi berupa distribusi probabilitas, kita juga dapat menghitung _loss_ menggunakancross
_entropy_. Seperti yang sudah dijelaskan sebelumnya
pada _binary classification_, kita ingin hasil perhitungan _cross entropy_ seke-
(^3) https://en.wikipedia.org/wiki/Softmax_ _function_
68 5 Model Linear
cil mungkin karena meminimalkan nilai _cross entropy_ meningkatkan _confidence_ saat
proses klasifikasi. Hal ini dapat dianalogikan dengan jargon “winner
takes it all”. Sebagai ilustrasi, lihatlah Gambar 5.5. Kita ingin agar bentuk
distribusi probabilitas _output_ kelas (c) condong ke salah satu sisi saja.
```
Gambar 5.5:Classification Entropy.
```
```
Gambar 5.6:One versus one.
```
```
5.4 Multi- _class_ Classification 69
```
```
Gambar 5.7:One versus all.
```
Selain mengekstensi suatu model untuk melakukan _multi-class classification_ secara
langsung, kita juga dapat menggabungkan beberapa model _binary_
_classifier_ untuk melakukan _multi-class classification_. Teknik ini memiliki dua
varian yaitu _one versus one_ dan _one versus all_.
Pada teknik _one versus one_, kita membuat sejumlah kombinasi pasangan
kelas
#### (N
```
2
```
#### )
, untukN= banyaknya kelas. Kemudian, kita biarkan masingmasing
_model_ mengklasifikasikan _input_ ke dalam satu dari dua kelas. Akhirnya,
kita memilih kelas klasifikasi berdasarkan kelas yang paling sering muncul dari
semua model. Hal ini diilustrasikan pada Gambar 5.6 (untuk lima kelas), dimanafi,jmelambangkan _binary_
_classifier_ untuk kelasidan kelasj.
Pada teknik _one versus all_, kita membuat sejumlah model juga, tetapi
kombinasinya tidak sebanyak _one versus one_. Model pertama mengklasifikasikan _inputs_ ebagai
kelas pertama atau bukan kelas pertama. Setelah itu,
dilanjutkan ke model kedua mengklasifikasikan _inputs_ ebagai kelas kedua atau
bukan kelas kedua, dan seterusnya. Hal ini diilustrasikan pada Gambar 5.7
(untuk lima kelas).
70 5 Model Linear
|
### 5.5 Multi-label Classification
Seperti halnya _multi-class classification_, kita dapat mendekomposisimultilabel
_classification_ menjadi beberapa _binary classifier_ (analogi persamaan 5.12).
Yang membedakan _multi-class_ dan _multi-label_ adalah outputc. Padamulti _class_
_classification_,ci∈cmelambangkan skor suatu _input_ masuk ke kelas
ci. Keputusan akhir _class assignment._ idapatkan dari elemencdengan nilai
terbesar. Untuk _multi-label classification_ nilaici∈cmelambangkan apakah
suatu kelas masuk ke kelasciatau tidak. Bedanya, kita boleh meng- _assign_
lebih dari satu kelas (atau tidak sama sekali). Misalci≥ 0 .5, artinya kita
anggap model tersebut layak masuk ke kelasci, tanpa harus membandingannya
dengan nilaicj(i 6 =j) lain. Inilah yang dimaksud dengan prinsipmutual
exclusivity. Perhatikan Tabel 5.1 sebagai ilustrasi, dimana “1” melambangkan
_class assignment._
```
InstanceAgama Politik Hiburan
Berita-1 1 0 0
Berita-2 0 1 0
Berita-3 0 0 1
```
```
(a) Multi- _class_ classification.
```
```
InstanceAgama Politik Hiburan
Berita-1 1 1 0
Berita-2 0 1 1
Berita-3 1 0 1
```
```
(b) Multi-label classification.
```
Tabel 5.1: Ilustrasi _multi-label_ dan _multi-class classification_. Nilai “1” melambangkan
TRUE dan “0” melambangkan FALSE ( _class assignment._.
Sekali lagi, nilaici∈cbernilai [0,1] tetapi keputusan klasifikasi apakah
suatu kelas masuk ke dalamcitidak bergantung pada nilaicj(i 6 =j) lainnya.
Berdasarkan prinsip _mutual exclusivity_, output cpada classifier 5.7
tidak ditransformasi menggunakan _softmax_. Pada umumnya, _multi-label classifier_ melewatkan _output_ cke
dalam fungsi sigmoid. Dengan demikian, persamaan
5.15 diganti menjadi persamaan 5.16 pada _multi-label classifier_.
ci= sigmoid(ci) (5.16)
Berhubung cara menginterpretasikan _output_ berbeda dengan _multi-class_
_classification_, cara evaluasi kinerja juga berbeda. Ada dua pendekatan evaluasi
pada _multi-label classification_. Pertama, kita evaluasi kinerja _binary classification_ untuk
setiap kelas. Pada pendekatan ini, seolah-olah kita memiliki
banyak _binary classifier_ untuk melakukan klasifikasi. Kedua, kita dapat
mengevaluasi kinerja _multi-label classification_ itu sendiri. Perhatikan Gambar
5.8! Pendekatan pertama ibarat membandingkan kolom _desired output_ untuk
masing-masing kelas dengan _prediction_ yang berkorespondensi. Pada pendekatan
kedua, kita membandingkan baris untuk tiap-tiap prediksi (seperti biasa).
Saat kita membandingkan tiap-tiap baris prediksi, kita bisa jadi menda-
```
5.6 Pembelajaran sebagai Permasalahan Optimisasi 71
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
```
```
Original
Instance Agama Politik Hiburan
Berita- 1 1 1 1
Berita- 2 0 1 1
Berita- 3 0 0 1
```
```
Prediction
```
```
Instance Agama Politik Hiburan
1 1 0
0 0 1
0 1 0
```
```
Exact match
Partially correct
Complete incorrect
```
```
Evaluate binary
_classification_ sepa _rate_ ly
```
```
Evaluate multi-label
_classification_ at once
Original Prediction
```
```
Gambar 5.8: Cara mengevaluasi _multi-label classifier_.
```
patkan prediksi tipe _exact match_ (seluruh prediksi sama dengan _desired output_ ),partially
correct(sebagian prediksi sama dengan _desired output_ ) atau
_complete incorrect_ (tidak ada prediksi yang sama dengan _desired output_ ).
Dengan ini, evaluasi _multi-label classification_ relatif lebih kompleks dibanding
_multi-class classification_ biasa. Untuk mendapatkan _multi-label classification_
accuracy, kita dapat menghitung berapa seberapa banyak _exact match_ dibandingkan
banyaknya _instance_ (walaupun hal ini terlalu ketat). Selain itu, kita
dapat menghitung _loss_ menggunakan _cross entropy_ untuk mengevaluasi kinerja
saat melatih _multi-label classifier_, layaknya _multi-class classifier_. Kamu
dapat membaca [29] lebih lanjut untuk teknik evaluasi _multi-label_ classifica-
tion.
|
### 5.7 Batasan Model Linear
Model linear, walaupun mudah dimengerti, memiliki beberapa batasan. Ada
dua batasan paling kentara [20]: (1) _additive assumption_ dan (2)linear as-
sumption.
_Additive assumption_ berarti model linear menganggap hubungan antara
_input_ dan _output_ adalah linear. Artinya, perubahan nilai pada suatu fiturxi
pada inputxakan merubah nilai _output_ secara independen terhadap fitur
lainnya. Hal ini terkadang berakibat fatal karena fitur satu dan fitur lainnya
dapat berinteraksi satu sama lain. Solusi sederhana untuk permasalahan ini
adalah dengan me _model_ kan interaksi antar-fitur, seperti diilustrasikan pada
persamaan 5.24 untuk _input_ yang tersusun atas dua fitur.
```
f(x) =x 1 w 1 +x 1 w 2 +x 1 x 2 w 3 +b (5.24)
```
Dengan persamaan 5.24, apabilax 1 berubah, maka kontribusix 2 terhadap
_output_ juga akan berubah (dan sebaliknya). Akan tetapi, seringkali interaksi
76 5 Model Linear
antar-fitur tidaklah sesederhana ini. Misal, semua fitur berinteraksi satu sama
lain secara non-linear.
_Linear assumption_ berarti perubahan pada suatu fiturximengakibatkan
perubahan yang konstan terhadap _output_, walaupun seberapa besar/kecil nilai
xitersebut. Seringkali, perubahan pada _output_ sesungguhnya bergantung juga
pada nilaixi itu sendiri, bukan hanya pada∆xi. Solusi sederhana untuk
permasalahan ini adalah me _model_ kan fungsi linear sebagai fungsi polinomial
dengan orde (M) tertentu, diilustrasikan pada persamaan 5.25. Akan tetapi,
pe _model_ an inipun tidaklah sempurna karena rawan _overfitting_.
```
f(x) =x 1 w 1 + +x^22 w 2 +···+xMMwM+b (5.25)
```
Asumsi yang sebelumnya dijelaskan pada pe _model_ an polinomial, dapat diekstensi
menjadi _generalized additive model_ (GAM) untuk mengatasi masalah
_linear assumption_, seperti diilustrasikan pada persamaan 5.26 [20]. Artinya,
kita melewatkan setiap fiturxipada suatu fungsigi, sehingga deltaxitidak
mengakibatkan perubahan yang konstan terhadap _output_. Ekstensi ini dapat
me _model_ kan hubungan non-linear antara fitur dan _output_.
```
f(x) =g 1 (x 1 ) + +g 2 (x 2 ) +···+gN(xN) +b (5.26)
```
Tetapi, GAM masih saja memiliki batasan _additive assumption_. Dengan
demikian, interaksi antar-variabel tidak dapat di _model_ kan dengan baik.
|
### 5.10 Transformasi Data
Seperti yang sudah dijelaskan sebelumnya, alangkah baik apabila semua data
memiliki hubungan secara linear atau bersifat _linearly separable_. Kenyataan-
(^10) https://en.wikipedia.org/wiki/Norm_(mathematics)
(^11) https://stats.stackexchange.com/questions/136895/
why-is-the-l1- _norm_ -in-lasso-not- _differentiable_
80 5 Model Linear
nya, kebanyakan data bersifat _non-linearly separable_. Kita dapat mentransformasi
_data_ yang bersifat _non-linearly separable_ menjadi _linearly-separable_ sebelum
menggunakan model linear untuk mengklasifikasikan data. Sebagai contoh,
perhatikan Gambar 5.15. Pada gambar bagian kiri, terdapat empat titik
yang _non-linearly separable_. Titik-titik itu ditransformasi sehingga menjadi
gambar bagian kanan. Fungsi transformasi yang digunakan diberikan pada
persamaan 5.30.
```
Gambar 5.15: Contoh transformasi [7].
```
```
φ(x,y) =
```
#### {√
```
x^2 +y^2 ≥ 2 →(4−x+‖x−y‖, 4 −x+‖x−y‖)
√
x^2 +y^2 ≤ 2 →(x,y)
```
#### (5.30)
Secara umum, fungsi transformasi tidaklah sesederhana contoh yang sudah
diberikan. Fungsi transformasi pada umumnya menambah dimensi data (misal
dari dua dimensi menjadi tiga dimensi). Beberapa fungsi transformasi (dikenal
juga dengan istilah _kernel_ ) yang terkenal diantaranya:^12
1. Fisher Kernel
2. Graph Kernel
3. Kernel Smoother
4. Polynomial Kernel
5. Radial Basis Function Kernel
6. String Kernel
Untuk penjelasan masing-masing _kernel_, silahkan membaca literatur lain lebih
lanjut. Model linear yang memanfaatkan fungsi-fungsi _kernel_ ini adalahsupport
vector machine(SVM) [31, 32]. Perhatikan, algorithma SVM sebenarnya
sangatlah penting. Akan tetapi, perlu kami informasikan bahwa buku ini tidak
memuat materi SVM secara detil. Dengan demikian, kami harap pembaca dapat
mencari referensi lain tentang SVM. Metode transformasi pun tidaklah
(^12) https://en.wikipedia.org/wiki/ _Kernel_ _method
```
5.11 Bacaan Lanjutan 81
```
sempurna, seperti yang akan dijelaskan pada bab 11, karena memang data secara
alamiah memiliki sifat yang non-linear. Dengan demikian, lebih baik apabila
kita langsung saja me _model_ kan permasalahan dengan fungsi non-linear.
|
### Soal Latihan
5.1. Hill Climbing
Baca dan jelaskanlah konsep Hill Climbing!
5.2. Variasi Optimisasi
Baca dan jelaskanlah variasi konsep optimisasi lain, selainstochastic gradient
descent!
5.3. Convex Optimization
Bacalah literatur yang memuat materi tentang _convex optimization_ ! Jelaskan
pada teman-temanmu apa itu fungsi _convex_ dan _concave_, tidak lupa isi materi
yang kamu baca! Bagaimana hubungan _convex optimization_ dan pembelajaran
mesin?
5.4. Sum of Squared Errors
Salah satu cara untuk mencari nilai parameter pada regresi adalah menggunakan
teknik _sum of squared errors_. Jelaskanlah bagaimana cara kerja metode
tersebut! (Hint: baca buku oleh James et al. [20])
5.5. Linear Discriminant Analysis
Jelaskan prinsip dan cara kerja _linear discriminant analysis_ ! (Hint: baca buku
oleh James et al. [20])
|
### 5.11 Bacaan Lanjutan
Kami harap pembaca mampu mengeksplorasi materi _kernel method_ dansupport
vector machine(SVM). Kami mencantumkan materi SVM pada buku ini
sedemikian pembaca mampu mendapatkan intuisi, tetapi tidaklah detil. Kami
sa _rank_ an kamu membaca pranalahttps://www.svm-tutorial.com/karena
ditulis dengan cukup baik. Mengerti materi SVM dan _convex optimization_
secara lebih dalam akan sangat membantu pada bab-bab berikutnya. Selain
itu, kami juga menya _rank_ an pembaca untuk melihat kedua pranala tambahan
tentang _learning rate_ dan momentum:
```
1.http:// _user_ s.ics.aalto.fi/jhollmen/dippa/ _node_ 22.html
2.http://www.willamette.edu/~gorr/ _class_ es/cs449/mom _rate_.html
```
|
### 5.6 Pembelajaran sebagai Permasalahan Optimisasi
Salah satu tujuan dari pembelajaran ( _training_ ) adalah untuk meminimalkan
_error_ sehingga kinerja learning machine ( _model_ ) diukur oleh squared error.
Dengan kata lain, _utility function_ adalah meminimalkan _squared error_.
Secara lebih umum, kita ingin meminimalkan/memaksimalkan suatu fungsi
yang dijadikan tolak ukur kinerja ( _utility function_ ), diilustrasikan pada per-
72 5 Model Linear
samaan 5.17, dimanaθadalah _learning parameter_,^4 ˆθadalah nilai parameter
paling optimal, danLadalah _loss function_. Perhatikan, “arg min” dapat juga
diganti dengan “arg max” tergantungoptimisasiapa yang ingin dilakukan.
Perubahan parameter dapat menyebabkan perubahan _loss_. Karena itu, _loss_
_function_ memilikiθsebagai parameternya.
```
θˆ= arg min
θ
```
```
L(θ) (5.17)
```
Sekarang, mari kita hubungkan dengan contoh yang sudah diberikan pada
subbab sebelumnya. Kita coba melakukan estimasi _minimum squared error_ E,
dengan mencari nilai _learning parameters_ wyang meminimalkan nilai _error_
pada model linear (persamaan 5.18).^5 Parameter model pembelajaran mesin
_bias_ anya diinisialisasi secara acak atau menggunakan distribusi tertentu. Terdapat
beberapa cara untuk memimalkan _squared error_. Yang penulis akan
bahas adalah _stochastic gradient descent method_.^6 Selanjutnya apda buku ini,
istilah _gradient descent_, _gradient-based method_ dan _stochastic gradient descent_
mengacu pada hal yang sama.
```
wˆ= arg min
w
```
```
E(w) (5.18)
```
Bayangkan kamu sedang berada di puncak pegunungan. Kamu ingin mencari
titik terendah pegunungan tersebut. Kamu tidak dapat melihat keseluruhan
pegunungan, jadi yang kamu lakukan adalah mencari titik terendah
(lokal) sejauh mata memandang, kemudian menuju titik tersebut dan menganggapnya
sebagai titik terendah (global). Layaknya asumsi sebelumnya,
kamu juga turun menuju titik terendah dengan cara melalui jalanan dengan
kemiringan paling tajam, dengan anggapan bisa lebih cepat menuju ke titik
terendah [9]. Sebagai ilustrasi, perhatikan Gambar 5.9! Seluruh area pegunungan
adalah nilai _error_ E yang mungkin (pada persoalanmu), dan titik
terendah pada daerah tersebut adalah nilai _error_ Eterendah.
Jalanan dengan kemiringan paling tajam adalah−grad E(w), dimana
E(w) adalah nilai _error_ saat model memiliki parameterw. Dengan definisi
gradE(w) diberikan pada persamaan 5.19 dan persamaan 5.20, dimanawi
adalah nilai elemen vektor ke-i.
```
gradE(w) =
```
#### (
#### ∂E
```
∂w 1
```
#### ,
#### ∂E
```
∂w 2
```
#### ,...,
#### ∂E
```
∂wF
```
#### )
#### (5.19)
(^4) Dapat berupa skalar, vektor, matriks, atau tensor. Demi istilah yang lebih generik,
kita gunakanθ.
(^5) wboleh diganti denganW, saat ini penulis menggunakan vektor untuk menyedenakan
pembahasan.
(^6) Konsep _Hill Climbing_ dapat digunakan untuk memaksimalkan _utility function_
Konsep tersebut sangat mirip dengan _gradient descent_ https://en.wikipedia.
org/wiki/Hill_climbing.
```
5.6 Pembelajaran sebagai Permasalahan Optimisasi 73
```
```
Gambar 5.9:Stochastic Gradient Descent.
```
```
dw
dt
```
```
=−gradE(w);t= _time_ (5.20)
```
Ingat kembali materi diferensial. Gradien adalah turunan (diferensial)
fungsi. Untuk mencari turunan paling terjal, sama halnya mencari nilai
− _gradient_ terbesar. Dengan demikian, menghitung −grad E(w) terbesar
sama dengan jalanan turun paling terjal. Tentunya seiring berjalannya waktu,
kita mengubah-ubah parameterwagar kinerja model optimal. Nilai optimal
diberikan oleh turunanwterhadap waktu, yang bernilai sama dengan
−gradE(w). Bentuk diskrit persamaan 5.20 diberikan pada persamaan 5.21,
```
w(t+ 1) =w(t)−ηgradE(w(t)) (5.21)
```
dimanaηdisebut _learning rate_ danw(t) adalah nilaiwsaat waktu/iterasi
t. _Learning rate_ digunakan untuk mengatur seberapa pengaruh keterjalan
terhadap pembelajaran. Silahkan mencari sumber tambahan lagi agar dapat
mengerti _learning rate_ secara lebih dalam/matematis. Pada implementasi,η
juga sering diubah-ubah nilainya sepanjang waktu. Semakin kita sudah dekat
dengan tujuan (titik _loss_ terendah), kita mengurangi nilaiη, ibaratnya seperti
mengerem kalau sudah dekat dengan tujuan [30].
Walaupun kamu berharap bisa menuju titik terendah dengan menelusuri
jalan terdekat dengan kemiringan paling tajam, tapi kenyataanya hal tersebut
bisa jadi bukanlah jalan tercepat, seperti yang diilustrasikan pada Gambar
5.10. Warna merah melambangkan jalan yang dilalui _gradient descent_,
sementara warna biru melambangkan jalanan terbaik (tercepat).
Pandangan kita yang terbatas layaknya kita tidak bisa melihat keseluruhan
pengunungan secara keseluruhan (anggap ada kabut), kita juga tidak
bisa melihat keseluruhan nilai _error_ untuk semua parameterw. Secara filosofis,
hal tersebut juga berlaku saat membaca buku, oleh karena itu sebaiknya kamu
membaca beberapa buku saat belajar.
Dalam _local point of view_, _steepest gradient descent_ adalah cara tercepat
menuju titik terendah, tetapi tidak pada _global point of view_. Kita dapat
macet/berhenti saat sudah mencapai _local minima_, yaitu nilai minimum pada
suatu daerah lokal saja. Sebagai ilustrasi, perhatikan Gambar 5.11. Kamu
berada di puncak pegunungan kemudian turun bertahap. Kemudian, kamu
sampai di suatu daerah landai (−gradE(w) = 0). Kamu pikir daerah landai
74 5 Model Linear
```
Gambar 5.10:Stochastic Gradient Descent2.
```
```
Local Minima
−grad 𝐸𝒘 = 0
```
```
Global Minimum
−grad 𝐸𝒘 = 0
```
```
Start Point
```
```
Andaiaku
sebelumnya
meloncat!
```
```
Loncat
```
```
Gambar 5.11:Stuck at local minima.
```
tersebut adalah titik terendah, tetapi, kamu ternyata salah. Untuk menghindari
hal tersebut, kita menggunakan _learning rate_ (η). Apabila nilai _learning_
_rate_ (η) pada persamaan 5.21 relatif kecil, maka dinamika perubahan parameterwjuga
kecil. Tetapi, bila nilainya besar, maka jalanan menuju titik terendah
akan bergoyang-goyang ( _swing_ ), seperti pada Gambar 5.12. Goyangan
tersebut ibarat “meloncat-loncat” pada ilustrasi Gambar 5.11. Kemampuan
untuk “meloncat” ini dapat menghindarkan model _stuck_ di _local minima_.
Untuk mengontrol _learning parameter_ wsehingga memberikan nilaiE(w)
terendah, persamaan _steepest gradient descent_ dapat ditambahkan dengan
```
5.7 Batasan Model Linear 75
```
```
Gambar 5.12:Swing.
```
_momentum_ (α) pada persamaan 5.23. Alfa adalah momentum karena dikalikan
dengan hasil perbedaan descent pada tahap sebelumnya. Alfa adalah
parameter kontrol tambahan untuk mengendalikan _swing_ yang sudah dibahas
sebelumnya.
```
w(t+ 1) =w(t)−ηgradE(w(t)) +α(∆w) (5.22)
```
∆w=w(t)−w(t−1) (5.23)
Apabila gradien bernilai 0, artinya model sudah berada pada titiklocal/global
optimum. Kondisi ini disebut sebagaikonvergen( _converging_ ). Sementara
_model_ yang tidak menuju titik optimal, malah menuju ke kondisi
yang semakin tidak optimum, disebut _divergen_ ( _diverging_ ).
|
### 5.8 Overfitting dan Underfitting
Tujuan _machine learning_ adalah membuat model yang mampu memprediksi
_data_ yang belum pernah dilihat ( _unseen instances_ ) dengan tepat; disebut sebagai
generalisasi ( _generalization_ ). Seperti yang sudah dijelaskan pada bab
pertama, kita dapat membagi dataset menjadi _training_, _validation_, dan _testing_ _dataset_.
Ketiga dataset ini berasal dari populasi yang sama dan dihasilkan
oleh distribusi yang sama ( _identically and independently distributed_ ). Dalam
artian, ketiga jenis dataset mampu melambangkan (merepresentasikan) karakteristik
yang sama.^7 Dengan demikian, kita ingin _loss_ atau _error_ pada _training_, _validation_,
dan _testing_ bernilai kurang lebih bernilai sama (i.e., kinerja
yang sama untuk data dengan karakteristik yang sama). Akan tetapi, _underfitting_ dan _overfitting_ mungkin
terjadi.
_Underfitting_ adalah keadaan ketika kinerja model bernilai buruk baik pada
_training_ atau _validation_ maupun testing data. _Overfitting_ adalah keadaan
ketika kinerja model bernilai baik untuk _training_ tetapi buruk pada unseen
_data_. Hal ini diilustrasikan pada Gambar 5.13. _Underfitting_ terjadi akibat
_model_ yang terlalu tidak fleksibel, yaitu memiliki kemampuan yang rendah
untuk mengestimasi variasi fungsi. Sedangkan, _overfitting_ terjadi ketika
(^7) Baca teknik _sampling_ pada buku statistika.
(^8) Rekonstruksi https://www.inf.ed.ac.uk/teaching/courses/iaml/slides/
eval-2x2.pdf
```
5.8 Overfitting dan Underfitting 77
```
```
Gambar 5.13: _Underfitting_ vs _Overfitting_.^8
```
_model_ terlalu fleksibel, yaitu memiliki kemampuan yang terlalu tinggi untuk
mengestimasi banyak fungsi atau terlalu mencocokkan diri terhadap _training_ data.
Perhatikan kembali Gambar 5.13, dataset asli diambil ( _sampled_ )
dari fungsi polinomial orde-3. Model _underfitting_ hanya mampu mengestimasi
dalam orde-1 (kemampuan terlalu rendah), sedangkan model _overfitting_
mampu mengestimasi sampai orde-9 (kemampuan terlalu tinggi).
Apabila kita gambarkan grafik kinerja terhadap konfigurasi model ( _model_
order), fenomena underfitting dan overfitting dapat diilustrasikan seperti
Gambar 5.14. Model yang ideal adalah model yang memiliki kinerja yang baik
pada _training_, _validation_, dan _testing_ data. Artinya, kita ingin perbedaan kinerja
_model_ pada berbagai dataset bernilai sekecil mungkin. Untuk menghindari _overfitting_ atau _underfitting_,
kita dapat menambahkan fungsi _noise/bias_
(selanjutnya disebut _noise/bias_ saja) dan regularisasi (subbab 5.9). Hal yang
paling perlu pembaca pahami adalah untuk jangan merasa senang ketika
_model_ _machine learning_ yang kamu buat memiliki kinerja baik pada _training_
_data_. Kamu harus mengecek pada _validation_ dan _testing_ data, serta memastikan
kesamaan karakteristik data, e.g., apakah _training_ dan _testing_ data benar
diambil dari distribusi yang sama. Selain itu, kamu juga harus memastikan
apakah data yang digunakan mampu merepresentasikan kompleksitas pada
permasalahan asli/dunia nyata. Sering kali, dataset yang digunakan pada
banyak eksperimen adalah _toy dataset_, semacam simplifikasi permasalahan
dengan banyak sampel yang relatif sedikit. Kamu harus hati-hati terhadap
78 5 Model Linear
```
_Error_
```
```
Model order
```
```
_Training_ Error
```
```
Generalization (Testing) Error
```
```
_Underfitting_ Area Overfitting Area
```
```
Optimal Performance (Optimal Model)
```
```
Gambar 5.14:Selection Error.
```
_overclaiming_, i.e., menjustifikasi model dengan performa baik pada _toy dataset_
sebagai model yang baik secara umum.
|
### 5.3 Log-linear Binary Classification
Pada subbab sebelumnya, telah dijelaskan fungsi binary classifier memetakan
_data_ menjadi nilai [− 1 ,1], dengan−1 merepresentasikan kelas pertama dan
1 merepresentasikan kelas kedua. Tidak hanya kelas yang berkorespondensi,
kita juga terkadang ingin tahu seberapa besar peluang data tergolong pada
kelas tersebut. Salah satu alternatif adalah dengan menggunakan fungsi sigmoid
dibanding fungsi _sign_ untuk merubah nilai fungsi menjadi [0,1] yang
merepresentasikan peluangp _data_ diklasifikasikan sebagai kelas tertentu (1−p
untuk kelas lainnya). Konsep ini dituangkan menjadi persamaan 5.9, dimana
ymerepresentasikan probabilitas _input x_ digolongkan ke kelas tertentu,x
merepresentasikan data ( _feature vector_ ), danbmerepresentasikan _bias_. Ingat
kembali materi bab 4, algoritma _Naive Bayes_ melakukan hal serupa.
Hasil fungsi sigmoid, apabila di- _plot_ maka akan berbentuk seperti Gambar 5.1
(berbentuk karakter “S”).
66 5 Model Linear
```
y=σ(f(x)) =
```
#### 1
```
1 +e−(x·w+b)
```
#### (5.9)
Perhatikan, persamaan 5.9 juga dapat diganti dengan persamaan 5.10 yang
dikenal juga sebagai fungsi logistik.
```
y= logistik (f(x)) =
```
```
e(x·w+b)
1 +e(x·w+b)
```
#### (5.10)
Varibelyadalah nilai probabilitas data masuk ke suatu kelas. Sebagai contoh,
kita ingin nilaiy= 1 apabila data cocok masuk ke kelas pertama dany= 0
apabila masuk ke kelas kedua.
Ketika fungsi _machine learning_ menghasilkan nilai berbentuk probabilitas,
kita dapat menggunakan _cross entropy_ sebagai _utility function_. Persamaan
5.11 adalah cara menghitung _cross entropy_, dimanaT(ci) melambangkan
_desired probability_ ( _desired output_ ).P(ci) melambangkan probabilitas
(prediksi) _input_ diklasifikasikan ke kelasci danN melambangkan
banyaknya kelas. Untuk _binary classification_,T(c 1 ) = 1−T(c 2 ). Pada umumnya,Tbernilai
antara [0, 1]. Nilai 1 untuk kelas yang berkorespondensi dengan
_input_ ( _desired output_ ) dan 0 untuk kelas lainnya.
#### H=−
#### ∑N
```
i=1
```
```
T(ci) log (P(ci)) (5.11)
```
Kita ingin meminimalkan nilai _cross entropy_ untuk model pembelajaran
mesin yang baik. Ingat kembali materi teori informasi, nilai _entropy_ yang rendah
melambangkan distribusi tidak _uniform_. Sementara, nilai _entropy_ yang
tinggi melambangkan distribusi lebih _uniform_. Artinya, nilai _cross entropy_
yang rendah melambangkan _high confidence_ saat melakukan klasifikasi. Kita
ingin model kita se _bias_ a mungkin menghasilkan _output_ bernilai 1 untuk
mendiskriminasi seluruh data yang masuk ke kelas pertama, dan 0 untuk kelas
lainnya. Dengan kata lain, model dapat mendiskriminasi data dengan pasti.
_Cross entropy_ bernilai tinggi apabila perbedaan nilai probabilitas masuk ke
kelas satu dan kelas lainnya tidak jauh, e.g.,P(c 1 ) = 0.6 &P(c 2 ) = 0.4. Semakin
rendah nilai _cross entropy_, kita bisa meningkatkan “keyakinan” kita
terhadap kemampuan klasifikasi model pembelajaran mesin, yaitu perbedaan
nilai probabilitas masuk ke kelas satu dan kelas lainnya tinggi, e.g.,
P(c 1 ) = 0.8 &P(c 2 ) = 0.2.
|
### 5.2 Binary Classification
_Binary classification_ adalah mengklasifikasikan data menjadi dua kelas ( _binary_ ).
Contoh model linear sederhana untuk _binary classification_ diberikan
pada persamaan 5.6. Perhatikan, pada persamaan 5.6, suatu data direpresentasikan
sebagai _feature vector_ x, dan terdapat _bias_ b.^2 Klasifikasi dilakukan
dengan melewatkan data pada fungsi yang memiliki parameter. Fungsi tersebut
menghitung bobot setiap fitur pada vektor dengan mengalikannya dengan
parameter ( _dot product_ ). Persamaan 5.6 dapat ditulis kembali sebagai
persamaan 5.7, dimanaximerupakan elemen ke-idari vektorx. Fungsi ini
memiliki _range_ [−∞,∞]. Pada saat ini, kamu mungkin bingung. Bagaimana
mungkin fungsi regresi yang menghasilkan nilai kontinu digunakan untuk
klasifikasi kelas kategorial. Kita dapat menggunakan _thresholding_, atau dengan
memberikan batas nilai tertentu. Misal, bilaf(x)> thresholdmaka dimasukkan
ke kelas pertama; dan sebaliknyaf(x)≤ _threshold_ dimasukkan
ke kelas kedua. _Threshold_ menjadi bidang pembatas antara kelas satu dan
kelas kedua ( _decision boundary_, Gambar 5.3). Pada umumnya, teknik _threshold_ diterapkan
dengan menggunakan fungsi _sign_ (sgn, Gambar 5.4) untuk
merubah nilai fungsi menjadi [− 1 ,1] sebagai _output_ (persamaan 5.8); dimana
−1 merepresentasikan _input_ dikategorikan ke kelas pertama dan nilai 1 merepresentasikan _input_ dikategorikan
ke kelas kedua.
```
f(x) =x·w+b (5.6)
```
```
f(x) =x 1 w 1 +x 1 w 2 +···+xNwN+b (5.7)
```
_output_ = sgn(f(x) (5.8)
Seperti halnya fungsi regresi, kita juga dapat menghitung performa _binary_
_classifier_ sederhana ini menggunakan _squared error function_ (umumnya
menggunakan akurasi), dimana nilai target fungsi berada pada range [− 1 ,1].
Secara sederhana, model _binary classifier_ mencari _decision boundary_, yaitu
garis (secara lebih umum, _hyperplane_ ) pemisah antara kelas satu dan lainnya.
Sebagai contoh, garis hitam pada Gambar 5.3 adalah _decision boundary_.
(^2) Perhatikan! _Bias_ pada variabel fungsi memiliki arti yang berbeda dengan _statistical_
_bias_
```
5.3 Log-linear Binary Classification 65
```
```
Gambar 5.3: Contoh _decision boundary_.
```
```
Gambar 5.4: Fungsi _sign_.
```
|
### 5.9 Regularization
_Gradient-based method_ mengubah-ubah parameter modelwsehingga _loss_ dapat
diminimalkan. Perhatikan kembali Gambar 5.2, ibaratnya agar fungsi
aproksimasi kita menjadi sama persis dengan fungsi asli pada Gambar 5.1.
Perhatikan, karena nilaiwberubah-ubah seiring waktu, bisa jadi urutan _training_
_data_ menjadi penting.^9 Pada umumnya, kita menggunakan _batch method_
agar kinerja model tidak bias terhadap urutan data. Artinya, menghitung
_loss_ untuk beberapa data sekaligus. Hal ini akan kamu lebih mengerti setelah
mambaca bab 11.
Selain permasalahan model yang sensitif terhadap urutan _training data_,
_model_ yang kita hasilkan bisa jadi _overfitting_ juga. Yaitu memiliki kinerja
baik pada _training data_, tetapi memiliki kinerja buruk untuk _unseen data_.
Salah satu cara menghindari _overfitting_ adalah dengan menggunakan _regularization_.
Idenya adalah untuk mengontrol kompleksitas parameter (i.e. konfigurasi
parameter yang lebih sederhana lebih baik). Dengan ini, objektif _training_
pada persamaan 5.17 dapat kita ubah menjadi persamaan 5.27, dimana R(w)
adalah fungsi _regularization_ danλadalah parameter kontrol.
```
wˆ= arg min
w
```
```
L(w) +λR(w) (5.27)
```
(^9) Baca buku Yoav Goldberg [1] untuk mendapat penjelasan lebih baik.
```
5.10 Transformasi Data 79
```
Pilihan umum untuk fungsi _regularization_ pada umumnya adalahL 2 dan
L 1 norm. L 2 regularization menggunakan jumlah kuadrat dari Euclidean
_norm_ ^10 seluruh parameter, seperti pada persamaan 5.28. Sedangkan,L 1 regularizationmenggunakan
jumlah dari nilai _absolute-value norm_ seluruh parameter,
diberikan pada persamaan 5.29.
```
R(w) =‖w‖^22 =
```
#### ∑
```
i
```
```
(wi)^2 (5.28)
```
```
R(w) =‖w‖=
```
#### ∑
```
i
```
```
|wi| (5.29)
```
Perlu kamu perhatikan, metode _gradient descent_ memiliki syarat bahwa
fungsi yang digunakan haruslah dapat diturunkan ( _differentiable_ ).L 2 dapat
diturunkan pada seluruh poin, sementaraL 1 tidak dapat diturunkan pada semua
poin.^11 Kita dapat menggunakan teknik _subgradient_ untuk menyelesaikan
permasalahan ini. Kami serahkan pembaca untuk mengeksplorasi teknik tersebut
sendiri. Implikasi penggunakan regularisasi terhadap kompleksitas model
dibahas lebih lanjut pada bab 9.
Selain itu, ada hal lainnya yang perlu diperhatikan saat menggunakan
_gradient descent_ yaitu apakah suatu fungsi _convex_ atau _concave_. Izinkan saya
mengutip pernyataan dari buku Yoav Goldberg [1] halaman 31 secara langsung
menggunakan bahasa Inggris agar tidak ada makna yang hilang.
```
Convexity. In gradient-based optimization, it is common to distinguish between _convex_ (or _concave_ )
_function_ s and _non-concave_ functions. A _convex_
_function_ is a function whose second-derivative is always non-negative. As a
consequence, convex functions have a single minimum point. Similarly, _concave_
_function_ sare functions whose second-derivatives are always negative or
zero, and as a consequence have a single maximum point. Convex ( _concave_ )
_function_ s have the property that they are easy to minimize (maximize) using
_gradient-based optimization_ –simply follow the gradient until an extremum
_point_ is reached, and once it is reached we know we obtained the global extremum
_point_. In contrast, for functions that are neither convex or concave,
a gradient-based optimization procedure may converge to a local extremum
_point_, missing the global optimum.
```
|
### 5.1 Curve Fitting dan Error Function
Pertama, penulis ingin menceritakan salah satu bentuk _utility function_ untuk
_model_ matematis bernama _error function_. Fungsi ini sudah banyak diceritakan
pada bab-bab sebelumnya secara deskriptif. Mulai bab ini, kamu akan
mendapatkan pengertian lebih jelas secara matematis.
_Error function_ paling mudah dijelaskan dalam permasalahan regresi.
Diberikan (x,y)∈Rsebagai _random variable_. Terdapat sebuah fungsif(x)→
y, yang memetakanxkey, berbentuk seperti pada Gambar 5.1. sekarang
fungsif(x) tersebut disembunyikan (tidak diketahui), diberikan contoh-contoh
pasangan (xi,yi),i= 1, 2 ,...,6; yang direpresentasikan dengan lingkaran biru
pada ruang dua dimensi (titik sampel). Tugasmu adalah untuk mencari tahu
f(x)! Dengan kata lain, kita harus mampu memprediksi sebuah bilangan riil
y, diberikan suatux.
Kamu berasumsi bahwa fungsif(x) dapat diaproksimasi dengan fungsi
linearg(x) =xw+b. Artinya, kamu ingin mencariwdanbyang memberikan
62 5 Model Linear
```
Gambar 5.1: Contoh fungsi Sigmoid. Titik biru merepresentasikan sampel.
```
nilai sedemikian sehinggag(x) mirip denganf(x).wadalah parameter sementarabadalah _bias_.
Anggap kamu sudah berhasil melakukan pendekatan dan
menghasilkan fungsi linearg(x); seperti Gambar 5.2 (garis berwarna hijau).
Akan tetapi, fungsi approksimasi ini tidak 100% tepat sesuai dengan fungsi
aslinya (ini perlu ditekankan).^1 Jarak antara titik biru terhadap garis hijau
disebut _error_.
```
Gambar 5.2: Pendekatan fungsi Sigmoid.
```
Salah satu cara menghitung _error_ fungsig(x) adalah menggunakansquared
_error function_ dengan bentuk konseptual pada persamaan 5.1. Estimasi terhadap
persamaan tersebut disajikan dalam bentuk diskrit pada persamaan 5.2,
dimana (xi,yi) adalah pasangan _training data_ ( _input_ dan _desired output_ ).
Nilai _squared error_ dapat menjadi tolak ukur untuk membandingkan kinerja
(^1) Kamu patut curiga apabila model pembelajaran mesinmu memberikan kinerja
100%
```
5.1 Curve Fitting dan Error Function 63
```
suatu _learning machine_ ( _model_ ). Secara umum, bila nilainya tinggi, maka kinerja
dianggap relatif buruk; sebaliknya bila rendah, kinerja dianggap relatif
baik. Hal ini sesuai dengan konsep _intelligent agent_ [5].
```
E(g) =
```
#### ∫ ∫
```
‖y−g(x)‖^2 q(x,y)dx dy (5.1)
```
```
E(g) =
```
#### 1
#### N
#### ∑N
```
i=1
```
```
‖yi−g(xi)‖^2 (5.2)
```
Secara konseptual, bentuk fungsi regresi dilambangkan sebagai persamaan
5.3 [9].
```
g(x) =
```
#### ∫
```
y q(y|x)dy (5.3)
```
Persamaan 5.3 dibaca sebagai “ _expectation of_ y, _with the distribution of_ q.”
Secara statistik, regresi dapat disebut sebagai ekspektasi untukyberdasarkan/
dengan _input x_. Perlu diperhatikan kembali, regresi adalah pendekatan sehingga
belum tentu 100% benar (hal ini juga berlaku pada modelmachine
_learning_ pada umumnya).
Kami telah memberikan contoh fungsi linear sederhana, yaitug(x) =
xw+b. Pada kenyataannya, permasalahan kita lebih dari persoalan skalar.
Untukx( _input_ ) yang merupakan vektor, biasanya kita mengestimasi dengan
lebih banyak variable, seperti pada persamaan 5.4. Persamaan tersebut dapat
ditulis kembali dalam bentuk aljabar linear sebagai persamaan 5.5.
```
g(x) =x 1 w 1 +x 2 w 2 +···+xNwN+b (5.4)
```
g(x) =x·w+b (5.5)
Bentuk persamaan 5.4 dan 5.5 relatif _interpretable_ karena setiap fitur
pada _input_ (xi) berkorespondensi hanya dengan satu parameter bobotwi.
Artinya, kita bisa menginterpretasikan seberapa besar/kecil pengaruh suatu
fiturxiterhadap keputusan ( _output_ ) berdasarkan nilaiwi. Hal ini berbeda
dengan algoritma non-linear (misal _artificial neural network_, bab 11) dimana
satu fitur pada _input_ bisa berkorespondensi dengan banyak parameter bobot.
Perlu kamu ingat, model yang dihasilkan oleh fungsi linear lebih mudah dimengerti
dibanding fungsi non-linear. Semakin suatu model pembelajaran
mesin berbentuk non-linear, maka ia semakin susah dipahami.
Ingat kembali bab 1, _learning machine_ yang direpresentasikan dengan
fungsigbisa diatur kinerjanya dengan parameter _training_ w. _Squared error_
untuk _learning machine_ dengan parameter _training_ wdiberikan oleh persamaan
5.2, dimana (xi,yi) adalah pasangan _input-desired output_. Selain untuk
menghitung _squared error_ pada _training data_, persamaan 5.2 juga dapat
digunakan untuk menghitung _squared error_ pada _test data_. Tujuan dari regresi/machine
_learning_ secara umum adalah untuk meminimalkan nilai _loss_
64 5 Model Linear
baik pada _training_ maupun _unseen instances_. Misal, menggunakan _error function_ sebagai _proxy_ untuk _loss_.
Selain _error function_, ada banyak fungsi lainnya
seperti _Hinge_, _Log Loss_, _Cross-entropy loss_, _Ranking loss_ [1].
|
### 13.7 Transfer Learning
Walau konsep _transfer learning_ (TL) tidak terbatas pada _neural network_,
subbab ini membahas pemanfaatan TL paling umum pada _neural network_.
Pembaca dipersilahkan mengeksplorasi lebih lanjut.
Bayangkan kondisi berikut. Ada dua orang, Haryanto dan Wira. Saat
masih kecil, Wira pernah belajar cara memainkan Ukulele, sedangkan Haryanto
tidak. Ketika kedua orang tersebut belajar memainkan gitar, menurutmu
siapa yang bisa menguasai gitar lebih cepat?
Pada TL, kita ingin menggunakan suatu pengetahun ( _knowledge_ ) pada suatu _task_ T
1 , untuk menyelesaikan permasalahan _task_ T 2 [93, 94]. Kita memiliki
asumsi bahwaT 1 memiliki kaitan denganT 2 , sedemikian sehingga fasih pada
T 1 akan menyebabkan kita fasih padaT 2 (atau lebih fasih dibandingan tidak
menguasaiT 1 sama sekali). Perhatikan Gambar 13.27 yang mengilustrasikan
perbedaan pembelajaran mesin biasa dan penggunaan TL. Pada pembelajaran
mesin biasa, kita melatih model untuk masing-masing _task_. Pada TL,
kita menggunakan model yang sudah ada, disebut _pretrained model_, untuk
_task_ baru. Selain dimotivasi oleh kemiripan kedua _tasks_, TL juga dimotivasi
oleh ketersediaan data. Misal dataset untuk _task_ T 1 banyak, sedangkan untuk _task_ T
2 sedikit. BerhubungT 1 danT 2 memiliki kemiripan, model untuk
```
13.7 Transfer Learning 205
```
T 1 yang diadaptasi untukT 2 akan konvergen lebih cepat dibanding melatih
_model_ dari awal untukT 2.
Gambar 13.27: Pembelajaran mesin tradisional vs. menggunakantransfer
_learning_.
```
Gambar 13.28: Proses _transfer learning_.
```
Proses mengadaptasi suatu _pretrained model_ disebut _finetuning_ (Gambar
13.28). Pertama-tama kita ganti _layer terakhir_ ( _prediction layer_ ) pada
_pretrained model_ menggunakan _layer_ baru yang diinisialisasi secara _random_.^20
Kemudian, kita latih kembali model yang sudah ada menggunakan data untuk
T 2.
Secara umum, ada tiga cara untuk melakukan _finetuning_.
1.Freeze some layers. Kita _freeze_ beberapa _layer_ (parameternya tidak
diperbaharui saat fine _tuning_ ), kemudian latih _layer_ lainnya. Ilustrasi
diberikan pada Gambar 13.29.
2.Train only new last layer. Kita _freeze_ semua _layer_, kecuali _layer_ terakhir
untuk taskT 2. Ilustrasi diberikan pada Gambar 13.30
3.Train all layers. Setelah menggantu _layer terakhir_, kita latih semua _layer_
untuk taskT 2. Ilustrasi diberikan pada Gambar 13.31.
(^20) Penulis rasa, hal ini hampir wajib hukumnya
206 13 Arsitektur Neural Network
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Retrain Layer 1
```
```
Pretrained Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_ A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Freeze
```
```
Train
```
```
Train
```
```
Gambar 13.29:Freeze some layers.
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_ A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Freeze
```
```
Train
```
```
Gambar 13.30:Train only new last layer.
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Retrain Layer 1
```
```
Retrain Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_ A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Train
```
```
Gambar 13.31:Train all layers.
```
Selain alasan yang sudah disebutkan, TL juga digunakan untuk mempercepat _training_.
Konon _pre-trained_ model pada umumnya membutuhkan
waktu _training_ yang lebih cepat (lebih sedikit iterasi) dibanding melatih model
baru. Dengan demikian, kita dapat menghemat listrik dan mengurangi polusi
CO 2. TL juga berkaitan erat dengan _successive learning_ (bab 11), dimana
```
13.8 Multi- _task_ Learning 207
```
kita melatih arsitektur lebih kecil kemudian menggunakannya pada arsitektur
yang lebih besar.
Demikian konsep paling dasar TL. Selebihkan, penulis menya _rank_ an untuk
membaca _paper_ atau tutorial terkait, seperti dibawah berikut.
- https://www.cs.uic.edu/ liub/Lifelong- _Learning_ -tutorial-slides.pdf
- https://www.aclweb.org/anthology/attachments/
N19-5004.Presentation.pdf
|
### 13.3 Part-of-speech Tagging Revisited
Pada bab sebelumnya, kamu telah mempelajari konsep dasar _recurrent_ neural
_network_. Selain digunakan untuk klasifikasi (i.e., _hidden state_ terakhir digunakan
sebagai _input_ klasifikasi), RNN juga dapat digunakan untuk memprediksi
sekuens seperti persoalan _part-of-speech tagging_ (POS _tagging_ ) [82,
83, 84]. Kami harap kamu masih ingat materi bab 8 yang membahas apa itu
persoalan POS _tagging_.
Diberikan sebuah sekuens katax = {x 1 ,···,xT}, kita ingin mencari
sekuens _output_ y={y 1 ,···,yT}( _sequence prediction_ ); dimanayiadalah kelas
kata untukxi. Perhatikan, panjang _input_ dan _output_ adalah sama. Ingat
kembali bahwa pada persoalan POS _tagging_, kita ingin memprediksi suatu
kelas kata yang cocokyidari kumpulan kemungkinan kelas kataC ketika
diberikan sebuah _history_ seperti diilustrasikan oleh persamaan 13.5, dimana
_time_ lambangkan kandidat POStagke-i. Pada kasus ini, biasanya yang dicari
tahu setiap langkah ( _unfolding_ ) adalah probabilitas untuk memilih suatu
kelas katat∈Csebagai kelas kata yang cocok untuk di- _assign_ sebagaiyi.
Ilustrasi diberikan oleh Gambar. 13.14.
```
y 1 ,···,yT= arg max
t 1 ,···,tT;ti∈C
```
```
P(t 1 ,···,tT|x 1 ,···,xT) (13.5)
```
Apabila kita melihat secara sederhana ( _markov assumption_ ), hal ini tidak
lain dan tidak bukan adalah melakukan klasifikasi untuk setiap _instance_ pada
sekuens _input_ (persamaan 13.6). Pada setiap time step, kita ingin menghasilkan _output_ yang
bersesuaian.
```
yi= arg max
ti∈C
```
```
P(ti|xi) (13.6)
```
Akan tetapi, seperti yang sudah dibahas sebelum sebelumnya, _markov assumption_ memiliki
kelemahan. Kelemahan utama adalah tidak menggunakan
192 13 Arsitektur Neural Network
```
Gambar 13.14: POS _tagging_ menggunakan Recurrent Neural Network.
```
keseluruhan _history_. Persoalan ini cocok untuk diselesaikan oleh RNN karena
kemampuannya untuk mengingat seluruh sekuens (berbeda dengan _hidden_
markov model(HMM) yang menggunakan _markov assumption_ ). Secara teoritis
(dan juga praktis–sejauh yang penulis ketahui.) Pada banyak persoalan,
RNN menghasilkan performa yang lebih baik dibanding HMM. Tetapi hal ini
bergantung juga pada variasi arsitektur. Dengan ini, persoalan POS _tagging_
( _full history_ ) diilustrasikan oleh persamaan 13.7.
```
yi= arg max
ti∈C
```
```
P(ti|x 1 ,···,xT) (13.7)
```
Gambar 13.15:Sequence predictionmenggunakan Recurrent Neural Network.
Pada bab sebelumnya, kamu diberikan contoh persoalan RNN untuk satu
_output_ ; i.e., diberikan sekuens _input_, _output_ -nya hanyalah satu kelas yang
mengkategorikan seluruh sekuens _input_. Untuk persoalan POS _tagging_, kita
harus sedikit memodifikasi RNN untuk menghasilkan _output_ bagi setiap elemen
sekuens _input_. Hal ini dilakukan dengan cara melewatkan setiap _hidden_
_layer_ pada RNN pada suatu jaringan (anggap sebuah MLP+ _softmax_ ).
```
13.3 Part-of-speech Tagging Revisited 193
```
Gambar 13.16:Sequence predictionmenggunakan RNN (disederhakan) [1].
Persegi berwarna merah umumnya melambangkan _multi-layer perceptron_.
Kita lakukan prediksi kelas kata untuk setiap elemen sekuens _input_, kemudian
menghitung _loss_ untuk masing-masing elemen. Seluruh _loss_ dijumlahkan
untuk menghitung _backpropagation_ pada RNN. Ilustrasi dapat dilihat pada
Gambar. 13.15. Tidak hanya untuk persoalan POS _tagging_, arsitektur ini dapat
juga digunakan pada persoalan _sequence prediction_ lainnya sepertinamed
entity recognition.^10 Gambar. 13.15 mungkin agak sulit untuk dilihat, kami
beri bentuk lebih sederhananya (konseptual) pada Gambar. 13.16. Pada setiap
langkah, kita menentukan POStagyang sesuai dan menghitung _loss_ yang kemudian
digabungkan. _Backpropagation_ dilakukan dengan mempertimbangkan
keseluruhan (jumlah) _loss_ masing-masing prediksi.
Gambar 13.17:Sequence prediction menggunakan Recurrent Neural Network
(disederhakan), dimana prediksi saat waktu ke-tdipengaruhi oleh hasil
prediksi pada waktut−1.
Berdasarkan arsitektur yang sudah dijelaskan sebelumnya, prediksi POS
tagke-ibersifat independen dari POStaglainnya. Padahal, POStaglain-
(^10) https://en.wikipedia.org/wiki/Named-entity_recognition
194 13 Arsitektur Neural Network
nya memiliki pengaruh saat memutuskan POStagke-i(ingat kembali materi
bab 8); sebagai persamaan 13.8.
```
yi= arg max
ti∈C
```
```
P(ti|y 1 ,···,yi− 1 ,x 1 ,···,xi) (13.8)
```
Salah satu st _rate_ gi untuk menangani hal tersebut adalah dengan melewatkan
POStagpada sebuah RNN juga, seperti para persamaan 13.9 [1] (ilustrasi
pada Gambar. 13.17). Untuk mencari keseluruhan sekuens terbaik, kita
dapat menggunakan teknik _beam search_ (detil penggunaan dijelaskan pada
subbab berikutnya). RNNxpada persamaan 13.9 juga lebih intuitif apabila
diganti menggunakan _bidirectional RNN_ (dijelaskan pada subbab berikutnya).
```
P(ti|y 1 ,···,yi− 1 ,x 1 ,···,xi) =
_softmax_ (MLP([RNNx(x 1 ,···,xi); RNNtag(t 1 ,···,ti− 1 )]))
```
#### (13.9)
|
### Soal Latihan
13.1. POS _tagging_
Pada subbab 13.3, disebutkan bahwa _bidirectional recurrent neural network_
lebih cocok untuk persoalan POS _tagging_. Jelaskan mengapa! (hint pada
bab 8)
13.2. Eksplorasi
Jelaskanlah pada teman-temanmu apa dan bagaimana prinsip kerja:
(a) _Boltzman Machine_
(b) _Restricted Boltzman Machine_
(c) _Generative Adversarial Network_
|
### 13.6 Architecture Ablation
Pada bab 9, kamu telah mempelajari _feature ablation_, yaitu memilih-milih
elemen pada _input_ (untuk dibuang), sehingga model memiliki kinerja optimal.
Pada _neural network_, proses _feature engineering_ mungkin tidak sepenting
pada model- _model_ yang sudah kamu pelajari sebelumnya (e.g., model linear)
karena ia dapat me _model_ kan interaksi yang kompleks dari seluruh elemen
_input_. Pada _neural network_, masalah yang muncul adalah memilih arsitektur
yang tepat. Untuk menyederhanakan pencarian arsitektur, pada umumnya
kita dapat mengganggap sebuah _neural network_ tersusun atas beberapa
(^18) https:// _deep_ _learning_ 4j.org/restrictedboltzmannmachine
(^19) https:// _deep_ _learning_ 4j.org/ _generative_ -adversarial- _network_
204 13 Arsitektur Neural Network
“modul”. Pembagian _neural network_ menjadi modul adalah hal yang relatif.
Untuk mencari tahu konfigurasi arsitektur yang memberikan performa maksimal,
kita dapat melakukan _architecture ablation_. Idenya mirip denganfeature
ablation, dimana kita mencoba mengganti-ganti bagian (modul) neural network.
Sebagai contoh, ingat kembali arsitektur _sequence to sequence_ dimana
kita memiliki _encoder_ dan _decoder_. Kita dapat menggunakan RNN, Bidirectional
RNN, ataupun Stacked RNN sebagai _encoder_. Hal ini adalah salah satu
contoh _architecture ablation_. Akan tetapi, bisa jadi kita mengasumsikan modul
yang lebih kecil. Sebagai contoh, menggunakan RNN _encoder_ padasequence
to sequencedan kita coba mengganti-ganti fungsi aktivasi.
_Architecture ablation_ ini bisa menjadi semakin rumit tergantung persepsi
kita tentang definisi modul pada _neural network_, seperti sampai menentukan
jumlah _hidden layers_ dan berapa jumlah unit pada masing-masing _layer_. Contoh
lain adalah memilih fungsi aktivasi yang cocok untuk setiap _hidden layer_.
Pada kasus ini “modul” kita adalah sebuah _layer_. Walaupun _neural network_
memberikan kita kemudahan dari segi pemilihan fitur, kita memiliki kesulitan
dalam menentukan arsitektur. Terlebih lagi, alasan pemilihan banyaknya _units_
pada suatu _layer_ (e.g., 512 dibanding 256 _units_ ) mungkin tidak dapat dijustifikasi
dengan akurat. Pada _feature ablation_, kita dapat menjustifikasi alasan
untuk menghilangkan suatu fitur. Pada _neural network_, kita susah menjelaskan
alasan pemilihan arsitektur (dan konfigurasi parameter) karenasearch
_space_ -nya jauh lebih besar.
|
### 13.8 Multi- _task_ Learning
Subbab ini akan menjelaskan _framework_ melatih model pembelajaran mesin
menggunakan _multi-task learning_ (MTL). Walaupun konsep MTL tidak terbatas
pada _neural network_, bab ini membahas konsep tersebut menggunakan
arsitektur _neural network_ sebagai contoh (karena itu dimasukkan ke dalam
bab ini). Kami hanya memberikan penjelasan paling inti MTL menggunakan
contoh yang sederhana.
Pada MTL, kita melatih model untuk mengerjakan beberapa hal yang
mirip atau berkaitan, secara bersamaan. Misalnya, melatih model POS _tagging_
dan _named-entity recognition_ [95], mesin penerjemah untuk beberapa pasangan
bahasa [96], klasifikasi teks [97] dan _discourse parsing_ [98]. Karena model
dilatih untuk beberapa permasalahan yang mirip (sejenis), kita berharap agar
_model_ mampu mendapatkan “intuisi” dasar yang dapat digunakan untuk
menyelesaikan semua permasalahan. Perbedaan TL (dalam konteks pembahasan
sebelumnya) dan MTL terletak pada _timing_ pelatihan. Apabila pada
TL, model untuk _task_ T 1 danT 2 dilatih pada waktu yang berbeda, sedangkan
untuk MTL, dilatih bersamaan.
Perhatikan Gambar 13.32 yang merupakan ilustrasi permasalahan POS
_tagging_. Diberikan _input_ sekuens katax, kita ingin mencari sekuenstagy
terbaik untuk melambangkan kelas tiap kata. Kami harap kamu masih ingat
definisi permasalahan tersebut karena sudah dibahas pada bab-bab sebelumnya.
Kita ingin me _model_ kan _conditional probability_ p(y|x,θ). POS _tagging_
adalah salah satu _sequence tagging task_, dimana setiap elemen _input_ berkorespondensi
dengan elemen _output_. Kita dapat melatih model BiRNN ditambah
dengan MLP untuk melakukan prediksi kelas kata. Sebelumnya, telah
dijelaskan bahwa BiRNN mungkin lebih intuitif untuk POS _tagging_ dibanding
RNN biasa. Hal ini karena kita dapat me _model_ kan “konteks” kata (surrounding
_word_ s) dengan lebih baik, yaitu informasi dari kata sebelum dan sesudah
(BiRNN), dibanding hanya mendapat informasi dari kata sebelum (RNN).
Sekarang kamu perhatikan Gambar 13.33 yang mengilustrasikannamed
entity recognition task(NER). _Named entity_ secara sederhana adalah objek
yang bernama, misal lokasi geografis, nama perusahaan, dan nama orang.
Pada NER, kita ingin mengekstrasi _named entity_ yang ada pada _input_. _Task_
ini biasanya direpresentasikan dengan BIO _coding scheme_. Artinya, _output_
208 13 Arsitektur Neural Network
```
Gambar 13.32: POStagger.
```
untuk NER adalah pilihan B ( _begin_ ), I ( _inside_ ) dan O ( _outside_ ). Apabila suatu
kata adalah kata pertama dari suatu _named entity_, kita mengasosiasikannya
dengan _output_ B. Apabila suatu kata adalah bagian dari _named entity_, tetapi
bukan kata pertama, maka diasosiasikan dengan _output_ I. Selain keduanya,
diasosiasikan dengan _output_ O. Seperti POS _tagging_, NER juga merupakan
_sequence tagging_ karena kita ingin me _model_ kanp(y|x,θ) untukxadalah
_input_ danyadalah _output_ (BIO).
```
Gambar 13.33: _Named Entity Recognition_.
```
POS _tagging_ dan NER dianggap sebagai _task_ yang “mirip” karena keduanya
memiliki cara penyelesaian masalah yang mirip. Selain dapat diselesaikan
dengan cara yang mirip, kedua _task_ tersebut memiliki _nature_ yang sama. Dengan
alasan ini, kita dapat melatih model untuk POS _tagging_ dan NER dengan
kerangka _multi-task learning_. Akan tetapi, menentukan apakah dua _task_
memiliki _nature_ yang mirip ibarat sebuah seni (butuh _sense_ ) dibandinghard
science[1].
Gambar 13.34: _Multi-task Learning_ untuk POS _tagging_ danNamed Entity
Recognition.
```
13.8 Multi- _task_ Learning 209
```
Ide utama MTL adalah melatih _shared representation_. Sebagai ilustrasi,
perhatikan Gambar 13.34. Sebelumnya, kita melatih dua model dengan
BiRNN yang dilewatkan pada MLP. Pada saat ini, kita melatih BiRNN yang
dianggap sebagai _shared representation_. BiRNN diharapkan memiliki “intuisi”
untuk menyelesaikan kedua permasalahan, berhubung keduanya memiliki _nature_ yang
sama. Setiap _hidden layer_ pada BiRNN dilewatkan pada MLP untuk
melakukan prediksi pada masing-masing _task_. Tujuan utama MTL adalah untuk
meningkatkan kinerja. Kita melatih model untuk _task_ Xdengan meminjam
“intuisi” penyelesaikan dari _task_ Ydengan harapan “intuisi” yang dibawa
dari _task_ Y dapat memberikan informasi tambahan untuk penyelesaian _task_
X.
```
Gambar 13.35: _Multi-task Learning_ pada mesin translasi.
```
Perhatikan contoh berikutnya tentang MTL pada mesin translasi (Gambar
13.35). Pada permasalahan mesin translasi, kita melatih model menggunakan
_data_ paralel kombinasi pasangan bahasaX-Y.
Penggunaan MTL pada mesin mesin translasi pada umumnya dimotivasi
oleh dua alasan.
- Pada kombinasi pasangan bahasa tertentu, tersedia _dataset_ dengan jum-
lah yang banyak. Tetapi, bisa jadi kita hanya memiliki _dataset_ berukuran
kecil untuk bahasa tertentu. Sebagai contoh, data mesin translasi untuk
pasangan English-France lebih besar dibanding English-Indonesia. Karena
kedua kombinasi pasangan bahasa memiliki _nature_ yang cukup sama,
kita dapat menggunakan MTL sebagai kompensasi data English-Indonesia
210 13 Arsitektur Neural Network
```
yang sedikit agar model pembelajaran bisa konvergen. Dalam artian, _encoder_ yang
dilatih menggunakan sedikit data kemungkinan memiliki performa
yang kurang baik. Dengan ini, kita latih suatu _encoder_ menggunakan
_data_ English-France dan English-Indonesia agar model bisa konvergen.
Pada kasus ini, transfer learning juga dapat digunakan. Kita melatih
_model_ English-France, kemudian memasangkan _encoder_ yang sudah dilatih
dengan _decoder_ baru untuk bahasa Indonesia.
```
- Seperti yang sudah dijelaskan sebelumnya, kita ingin menggunakan “in-
tuisi” penyelesaian suatu permasalahan untuk permasalahan lainnya,
berhubung solusinya keduanya mirip. Dengan hal ini, kita harap kita
mampu meningkatkan kinerja model. Sebagai contoh, kombinasi pasangan
bahasa English-Japanese dan English-Korean, berhubung kedua bahasa
target memiliki struktur yang mirip.
Pada kerangka MTL, _utility function_ atau objektif _training_ adalah meminimalkanjoint
_loss_ semua _tasks_ (hal ini juga membedakan TL dan MTL),
diberikan pada persamaan 13.19. Kita dapat mendefinisikan _loss_ pada kerangka
MTL sebagai penjumlahan _loss_ pada masing-masing _task_, seperti pada persamaan
13.20. Apabila kita mengganggap suatu _task_ lebih penting dari _task_
lainnya, kita dapat menggunakan _weighted sum_, seperti pada persamaan 13.21.
Kita juga dapat menggunakan _dynamic weighting_ untuk memperhitungkan
_uncertainty_ pada tiap _task_, seperti pada persamaan 13.22 [99], dimanaσ
melambangkan varians _task-specific loss_.
```
LMTL=q(LT 1 ,...LTD) (13.19)
```
```
q(LT 1 ,...LTD) =
```
#### ∑D
```
i
```
```
LTi (13.20)
```
```
q(LT 1 ,...LTD) =
```
#### ∑D
```
i
```
```
αiLTi (13.21)
```
```
q(LTi,...LTD) =
```
#### ∑D
```
i
```
#### 1
```
2 σ^2 i
```
```
LTi+ ln(σi) (13.22)
```
Saat melatih MTL, tujuan _training_ dapat mempengaruhi proses penyajian
_data_. Seumpama saat melatih mesin translasi untuk English-{Chinese,
Japanese, Korean}, kita ingin menganggap English-Korean sebagai _main task_
sementara sisanya sebagai _supporting task_, kita dapat melakukan _pre-training_
menggunakan data English-Chinese dan English-Japanese terlebih dahulu,
diikuti oleh English-Korean (tetapi _loss_ tetap _joint loss_ ). Pada kasus ini,
penggunaan _joint weighted loss_ dapat dijustifikasi. Di lain pihak, apabila kita
mengganggap semua _tasks_ penting, kita dapat melakukan data _shuffling_ sehingga
urutan _training data_ tidak bias pa _data_ sk tertentu. Pada kasus ini,
```
13.8 Multi- _task_ Learning 211
```
```
Gambar 13.36: _Multi-task Learning_ setup.
```
penggunaan _joint loss_ –sumdapat dijustifikasi. Ilustrasi diberikan pada Gambar
13.36.
|
### 13.2 Recurrent Neural Network
Ide dasar _recurrent neural network_ (RNN) adalah membuat topologi jaringan
yang mampu merepresentasikan data _sequential_ (sekuensial) atau _time series_ [77],
misalkan data ramalan cuaca. Cuaca hari ini bergantung kurang
lebih pada cuaca hari sebelumnya. Sebagai contoh apabila hari sebelumnya
(^4) mathworks.com
```
13.2 Recurrent Neural Network 187
```
mendung, ada kemungkinan hari ini hujan.^5 Walau ada yang menganggap
sifat data sekuensial dan _time series_ berbeda, RNN berfokus sifat data dimana _instance_ waktu
sebelumnya (t−1) mempengaruhi _instance_ pada waktu
berikutnya (t). Intinya, mampu mengingat _history_.
Secara lebih umum, diberikan sebuah sekuens _input x_ = (x 1 ,···,xT).
Dataxt(e.g., vektor, gambar, teks, suara) dipengaruhi oleh data sebelumsebelumnya
( _history_ ), ditulis sebagaiP(xt | {x 1 ,···,xt− 1 }). Kami harap
kamu ingat kembali materi _markov assumption_ yang diberikan pada bab 8.
Pada _markov assumption_, diasumsikan bahwa dataxt( _data point_ ) hanya
dipengaruhi olehbeberapa data sebelumnya saja(analogi: _windowing_ ).
Setidaknya, asumsi ini memiliki dua masalah:
1. Menentukan _window_ terbaik. Bagaimana cara menentukan banyaknya
data sebelumnya (secara optimal) yang mempengaruhi data sekarang.
2. Apabila kita menggunakan _markov assumption_, artinya kita mengganggap
informasi yang dimuat oleh data lama dapat direpresentasikan oleh data
lebih baru, i.e.,xtjuga memuat informasixt−J,...,xt− 1 ;Jadalah ukuran
window. Penyederhanaan ini tidak jarang mengakibatkan informasi yang
hilang.
RNN adalah salah satu bentuk arsitektur ANN untuk mengatasi masalah
yang ada pada _markov assumption_. Ide utamanya adalah memorisasi,^6 kita
ingin mengingatkeseluruhansekuens (dibanding _markov assumption_ yang
mengingat sekuens secara terbatas), implikasinya adalah RNN yang mampu
mengenali dependensi yang panjang (misalxtternyata dependen terhadap
x 1 ). RNN paling sederhana diilustrasikan pada Gambar. 13.9. Ide utamanya
adalah terdapat _pointer_ ke dirinya sendiri.
Gambar 13.9: Bentuk konseptual paling sederhana Recurrent Neural Network.
Ilustrasi Gambar. 13.9 mungkin sedikit susah dipahami karena berbentuk
sangat konseptual. Bentuk lebih matematis diilustrasikan pada Gam-
(^5) Mohon bertanya pada ahli meteorologi untuk kebenaran contoh ini. Contoh ini
semata-mata pengalaman pribadi penulis.
(^6) Tidak merujuk hal yang sama dengan _dynamic programming_.
188 13 Arsitektur Neural Network
bar. 13.10 [77]. Perhitungan _hidden state_ pada waktu ke-tbergantung pada
_input_ pada waktu ke-t(xt) dan _hidden state_ pada waktu sebelumnya (ht− 1 ).
```
Gambar 13.10: Konsep Recurrent Neural Network.
```
Konsep ini sesuai dengan prinsip _recurrent_ yaitumengingat(memorisasi)
kejadian sebelumnya. Kita dapat tulis kembali RNN sebagai persamaan 13.1.
```
ht=f(xt,ht− 1 ,b) (13.1)
```
dimanafadalah fungsi aktivasi (non-linear, dapat diturunkan). Demi menyederhanakan
penjelasan, penulis tidak mengikutsertakan _bias_ (b) pada fungsifungsi
berikutnya. Kami berharap pembaca selalu mengingat bahwa bias
adalah parameter yang diikutsertakan pada fungsi _artificial neural network_.
Fungsifdapat diganti dengan variasi _neural network_,^7 misal menggunakan
_long short-term memory network_ (LSTM) [78]. Buku ini hanya akan menjelaskan
konsep paling penting, silahkan eksplorasi sendiri variasi RNN.
Secara konseptual, persamaan 13.1 memiliki analogi denganfull markov
chain. Artinya, _hidden state_ pada saat ke-tbergantung pada semua _hidden_
_state_ dan _inputs_ ebelumnya.
```
ht=f(xt,ht− 1 )
=f(xt,f(xt− 1 ,ht− 2 ))
=f(xt,f(xt− 1 ,f({x 1 ,···,xt− 2 },{h 1 ,···,ht− 3 })))
```
#### (13.2)
_Training_ pada _recurrent neural network_ dapat menggunakan metode _backpropagation_.
Akan tetapi, metode tersebut kurang intuitif karena tidak mampu
mengakomodasi _training_ yang bersifat sekuensial _time series_. Untuk itu, terdapat
metode lain bernama _backpropagation through time_ [79].
(^7) https://en.wikipedia.org/wiki/Recurrent_ _neural_ _ _network_
```
13.2 Recurrent Neural Network 189
```
Gambar 13.11: Konsep _feed forward_ pada Recurrent Neural Network (RNN).
Karena RNN menerima _input_ berupa sekuens, kita memvisualisasikan proses
feed fowarddengan _unfolding_ (atauunrolling) RNN pada keseluruhan sekuens
_input_.
Sebagai contoh kita diberikan sebuah sekuensxdengan panjangTsebagai
_input_, dimanaxtmelambangkan input ke-i( _data point_ ), dapat berupa
_vektor_, gambar, teks, atau apapun. Kita melakukan _feed forward_ data tersebut
ke RNN, diilustrasikan pada Gambar. 13.11. Perlu diingat, RNN mengadopsi
prinsip _parameter sharing_ (serupa dengan _weight sharing_ pada CNN)
dimana neuron yang sama diulang-ulang saat process _feed forward_. Setelah
selesai proses _feed forward_, kita memperbaharui parameter ( _synapse weights_ )
berdasarkan propagasi _error_ ( _backpropagation_ ). Pada _backpropagation_ biasa,
kita perbaharui parameter sambil mempropagasi _error_ dari _hidden state_ ke
_hidden state_ sebelumnya. Teknik melatih RNN adalah _backpropagation_
through timeyang melakukan _unfolding_ pada _neural network_. Kita meng _update_
parameter saat kita sudah mencapai _hidden state_ paling awal. Hal
ini diilustrasikan pada Gambar. 13.12.^8 Gambar. 13.12 dapat disederhanakan
menjadi bentuk lebih abstrak (konseptual) pada Gambar. 13.13.
Kita mempropagasi _error_ dengan adanya efek darinext states of hidden
_layer_. _Synapse weights_ diperbaharui secara _large update_. _Synapse weight_
tidak diperbaharui per _layer_. Hal ini untuk merepresentasikan _neural network_ yang
mampu mengingat beberapa kejadian masa lampau dan keputusan
saat ini dipengaruhi oleh keputusan pada masa lampau juga (ingatan).
Untuk mengerti proses ini secara praktikal (dapat menuliskannya sebagai program),
penulis sa _rank_ an pembaca untuk melihat materi tentangcomputation
graph^9 dan disertasi PhD oleh Mikolov [47].
Walaupun secara konseptual RNN dapat mengingat seluruh kejadian sebelumnya,
hal tersebut sulit untuk dilakukan secara praktikal untuk sekuens
yang panjang. Hal ini lebih dikenal dengan _vanishing_ atau _exploding_ gradient
problem[63, 80, 81]. Seperti yang sudah dijelaskan, ANN dan variasi arsitekturnya
dilatih menggunakan teknik _stochastic gradient descent_ ( _gradient_ -based
optimization). Artinya, kita mengandalkan propagasi _error_ berdasarkan tu-
(^8) Prinsip ini mirip dengan _weight sharing_.
(^9) https://www.coursera.org/learn/ _neural_ - _network_ s- _deep_ - _learning_ /
lecture/4WdOY/computation-graph
190 13 Arsitektur Neural Network
```
Gambar 13.12: Konsep _backpropagation through time_ [47].
```
Gambar 13.13: Konsep _backpropagation through time_ [1]. Persegi berwarna
merah umumnya melambangkan _multi-layer perceptron_.
runan. Untuk sekuens _input_ yang panjang, tidak jarang nilai _gradient_ menjadi
sangat kecil dekat dengan 0 ( _vanishing_ ) atau sangat besar ( _exploding_ ). Ketika
pada satu _hidden state_ tertentu, gradient pada saat itu mendekati 0, maka
nilai tersebut yang dipropagasikan pada langkah berikutnya menjadi semakin
kecil. Hal serupa terjadi untuk nilai gradient yang besar.
Berdasarkan pemaparan ini, RNN adalah teknik untuk merubah suatu
sekuens _input_, dimana xt merepresentasikan data ke-t(e.g., vektor, gambar,
teks) menjadi sebuah _output_ vektory. Vektorydapat digunakan un-
```
13.3 Part-of-speech Tagging Revisited 191
```
tuk permasalahan lebih lanjut (buku ini memberikan contoh _sequence to sequence_ pada
subbab 13.4). Bentuk konseptual ini dapat dituangkan pada persamaan
13.3. Biasanya, nilaiydilewatkan kembali ke sebuah _multi-layer perceptron_ (MLP)
dan fungsi softmax untuk melakukan klasifikasi akhir (final
_output_ ) dalam bentuk probabilitas, seperti pada persamaan 13.4.
```
y= RNN(x 1 ,···,xN) (13.3)
```
_final output_ = softmax(MLP(y)) (13.4)
Perhatikan, arsitektur yang penulis deskripsikan pada subbab ini adalah
arsitektur paling dasar. Untuk arsitektur _state-of-the-art_, kamu dapat membaca _paper_ yang
berkaitan.
|
### 13.5 Arsitektur Lainnya
Selain arsitektur yang sudah dipaparkan, masih banyak arsitektur lain baik
bersifat generik (dapat digunakan untuk berbagai karakteristik data) maupun
spesifik (cocok untuk data dengan karakteristik tertentu atau permasalahan
tertentu) sebagai contoh, _Restricted Boltzman Machine_ ^18 danGenerative Adversarial
Network(GAN).^19 Saat buku ini ditulis, GAN dan _adversarial training_ sedang
populer.
|
### 13.4 Sequence to Sequence
Pertama-tama, kami ingin mendeskripsikan kerangka _conditioned generation_.
Pada kerangka ini, kita ingin memprediksi sebuah kelasyiberdasarkan
kelas yang sudah di-hasilkan sebelumnya ( _history_ yaituy 1 ,···,yi− 1 ) dan sebuahconditioning
contextc(berupa vektor).
Arsitektur yang dibahas pada subbab ini adalah variasi RNN untuk permasalahansequence
_generation_.^11 Diberikan sekuens _input_ x= (x 1 ,···,xT).
Kita ingin mencari sekuens _output_ y= (y 1 ,···,yM). Pada subbab sebelumnya,xiberkorespondensi
langsung denganyi, e.g.,yiadalah kelas kata (kategori)
untukxi. Tetapi, pada permasalahan saat ini,xitidak langsung berkorespondensi
denganyi. Setiapyidikondisikan olehseluruhsekuens _input_ x;
i.e., _conditioning context_ dan _history_ {y 1 ,···,yi− 1 }. Panjang sekuens _output_
Mtidak mesti sama dengan panjang sekuens _input_ T. Permasalahan ini masuk
ke dalam kerangka _conditioned generation_ dimana keseluruhan _input_ x
dapat direpresentasikan menjadi sebuah vektorc( _coding_ ). Vektorcini menjadi
variabel pengkondisi untuk menghasilkan _output_ y.
Pasangan _input-output_ dapat melambangkan teks bahasa X–teks bahasa Y
(translasi), teks-ringkasan, kalimat- _paraphrase_, dsb. Artinya ada sebuah _input_
dan kita ingin menghasilkan ( _generate/produce_ ) sebuah _output_ yang cocok
untuk _input_ tersebut. Hal ini dapat dicapai dengan mo _model_ kan pasangan
_input-output_ p(y|x). Umumnya, kita mengasumsikan ada kumpulan parameterθyang
mengontrol _conditional probability_, sehingga kita transformasi
_conditional probability_ menjadip(y|x,θ). _Conditional probability_ p(y|x,θ)
dapat difaktorkan sebagai persamaan 13.10. Kami harap kamu mampu membedakan
persamaan 13.10 dan persamaan 13.5 (dan 13.8) dengan jeli. Sedikit
(^11) Umumnya untuk bidang pemrosesan bahasa alami.
```
13.4 Sequence to Sequence 195
```
perbedaan pada formula menyebabkan makna yang berbeda. Objektif _training_ adalah
untuk meminimalkan _loss function_, sebagai contoh berbentuklog
_likelihood_ function diberikan pada persamaan 13.11, dimanaDmelambangkan
_training data_.^12
```
p(y|x,θ) =
```
#### ∏M
```
t=1
```
```
p(yt|{y 1 ,...,yt− 1 },x,θ), (13.10)
```
```
L(θ) =−
```
#### ∑
```
{x,y}∈D
```
```
logp(y|x,θ) (13.11)
```
Persamaan 13.10 dapat di _model_ kan dengan _encoder-decoder_ model yang
terdiri dari dua buah RNN dimana satu RNN sebagai _encoder_, satu lagi sebagai _decoder_.Neural
Network, pada kasus ini, bertindak sebagaicontrolling
parameter θ. Ilustrasi encoder- _decoder_ dapat dilihat pada Gambar. 13.18.
Gabungan RNN _encoder_ dan RNN _decoder_ ini disebut sebagai bentuksequence
to sequence. Warna biru merepresentasikan _encoder_ dan warna
merah merepresentasikan _decoder_. “<EOS>” adalah suatu simbol spesial (untuk
praktikalitas) yang menandakan bahwa sekuens _input_ telah selesai dan
saatnya berpindah ke _decoder_.
Gambar 13.18: Konsep _encoder-decoder_ [81]. “<EOS>” adalah suatu simbol
spesial ( _untuk praktikalitas_ ) yang menandakan bahwa sekuens _input_ telah
selesai dan saatnya berpindah ke _decoder_.
Sebuah _encoder_ merepresentasikan sekuens _input_ xmenjadi satu vektor
c.^13 Kemudian, _decoder_ men- _decoder_ epresentasicuntuk menghasilkan ( _generate_ )
sebuah sekuens _output_ y. Perhatikan, arsitektur kali ini berbeda dengan
arsitektur pada subbab 13.3. _Encoder-decoder_ ( _neural network_ ) bertindak
sebagai kumpulan parameterθyang mengatur _conditional probability_.
_Encoder-decoder_ juga dilatih menggunakan prinsip _gradient-based optimization_ untuk _tuning_ parameter
yang mengkondisikan _conditional probability_ [81].
Dengan ini, persamaan 13.10 sudah didefinisikan sebagai _neural network_ sebagai
persamaan 13.12. “enc” dan “dec” adalah fungsi _encoder_ dan _decoder_,
yaitu sekumpulan transformasi non-linear.
(^12) Ingat kembali materi _cross entropy_ !
(^13) Ingat kembali bab 12 untuk mengerti kenapa hal ini sangat diperlukan.
196 13 Arsitektur Neural Network
```
yt= dec({y 1 ,···,yt− 1 },enc(x),θ) (13.12)
```
Begitu model dilatih, _encoder-decoder_ akan mencari _output_ ˆyterbaik untuk
suatu inputx, dillustrasikan pada persamaan 13.13. Masing-masing komponen
_encoder-decoder_ dibahas pada subbab-subbab berikutnya. Untuk abstraksi
yang baik, penulis akan menggunakan notasi aljabar linear. Kami harap pembaca
sudah familiar dengan representasi _neural network_ menggunakan notasi
aljabar linear seperti yang dibahas pada bab 11.
```
yˆ= arg max
y
```
```
p(y|x,θ) (13.13)
```
13.4.1 Encoder
Seperti yang sudah dijelaskan, _encoder_ mengubah sekuens _input x_ menjadi
satu vektorc. Suatu data point pada sekuens _input_ xt(e.g., kata, gambar,
suara, dsb) umumnya direpresentasikan sebagai _feature vector_ et. Dengan
demikian, _encoder_ dapat direpresentasikan dengan persamaan 13.14, dimana
fadalah fungsi aktivasi non-linear;UdanWadalah matriks bobot ( _weight_
matrices–merepresentasikan _synapse weights_ ).
```
ht=f(ht− 1 ,et)
=f(ht− 1 U+etW)
```
#### (13.14)
Representasi _input_ cdihitung dengan persamaan 13.15, yaitu sebagai
_weighted sum_ dari _hidden states_ [57], dimanaqadalah fungsi aktivasi nonlinear.
Secara lebih sederhana, kita boleh langsung menggunakanhTsebagai
konteksc[81] karena kita mengasumsikanhTmengandung seluruh informasi
yang ada di _input_.
c=q({h 1 ,···,hT}) (13.15)
Walaupun disebut sebagai representasi keseluruhan sekuens _input_, informasi
awal pada _input_ yang panjang dapat hilang. Artinyacbisa saja memuat
lebih banyak informasi _input_ ujung-ujung akhir. Salah satu st _rate_ gi yang dapat
digunakan adalah dengan membalik ( _reversing_ ) sekuens _input_. Sebagai
contoh, _input_ x= (x 1 ,···,xT) dibalik menjadi (xT,···,x 1 ) agar bagian awal
(···,x 2 ,x 1 ) lebih dekat dengan _decoder_ [81]. Informasi yang berada dekat dengan _decoder_ cenderung
lebih diingat. Kami ingin pembaca mengingat bahwa
teknik ini pun tidaklah sempurna.
13.4.2 Decoder
Seperti yang sudah dijelaskan sebelumnya, encoder memproduksi sebuah
_vektor_ cyang merepresentasikan sekuens _input_. _Decoder_ menggunakan representasi
ini untuk memproduksi ( _generate_ ) sebuah sekuens output y =
```
13.4 Sequence to Sequence 197
```
(y 1 ,···,yM), disebut sebagai proses _decoding_. Mirip dengan _encoder_, kita
menggunakan RNN untuk menghasilkan _output_ seperti diilustrasikan pada
persamaan 13.16, dimanafmerepresentasikan fungsi aktivasi non-linear;H,
E, danCmerepresentasikan _weight matrices_. _Hidden state_ h′tmelambangkan
distribusi probabilitas suatu objek (e.g., POS tag, kelas kata yangberasal
dari suatu himpunan) untuk menjadi _output_ yt. Umumnya,ytadalah dalam
bentuk _feature-vector_ e′t.
```
h′t=f(h′t− 1 ,e′t− 1 ,c)
=f(h′t− 1 H+e′t− 1 E+cC)
```
#### (13.16)
Dengan penjelasan ini, mungkin pembaca berpikir Gambar. 13.18 tidak
lengkap. Kamu benar! Penulis sengaja memberikan gambar simplifikasi. Gambar
lebih lengkap (dan lebih nyata) diilustrasikan pada Gambar. 13.19.
```
Gambar 13.19: Konsep _encoder-decoder_ (full).
```
Kotak berwarna ungu dan hijau dapat disebut sebagai _lookup matrix_ atau
_lookup table_. Tugas mereka adalah mengubah _input_ xtmenjadi bentukfeature
vector-nya (e.g., _word embedding_ ) dan mengubahe′tmenjadiyt(e.g., _word_
_embedding_ menjadi kata). Komponen “ _Beam Search_ ” dijelaskan pada subbab
berikutnya.
13.4.3 Beam Search
Kita ingin mencari sekuens _output_ yang memaksimalkan nilai probabilitas
pada persamaan 13.13. Artinya, kita ingin mencari _output_ terbaik. Pada su-
198 13 Arsitektur Neural Network
atu tahapan _decoding_, kita memiliki beberapa macam kandidat objek untuk
dijadikan _output_. Kita ingin mencari sekuens objek sedemikian sehingga probabilitas
akhir sekuens objek tersebut bernilai terbesar sebagai _output_. Hal ini
dapat dilakukan dengan algoritma _Beam Search_.^14
```
beamSearch(problemSet, ruleSet, memorySize)
openMemory = new memory of size memorySize
_node_ List = problemSet.listOfNodes
_node_ = root or initial search node
add node to OpenMemory;
while( _node_ is not a goal node)
delete node from openMemory;
expand node and obtain its children, evaluate those children;
if a child node is pruned according to a rule in ruleSet, delete it;
place remaining, non-pruned children into openMemory;
if memory is full and has no room for new nodes, remove the worst
_node_, de _term_ ined by ruleSet, in openMemory;
_node_ = the least costly node in openMemory;
```
```
Gambar 13.20: _Beam Search_.^15
```
Secara sederhana, algoritma _Beam Search_ mirip dengan algoritma Viterbi
yang sudah dijelaskan pada bab 8, yaitu algoritma untuk mencari sekuens
dengan probabilitas tertinggi. Perbedaannya terletak padaheuristic. Untuk
menghemat memori komputer, algoritma _Beam Search_ melakukan ekspansi
terbatas. Artinya mencari hanya beberapa (B) kandidat objek sebagai sekuens
berikutnya, dimana beberapa kandidat objek tersebut memiliki probabilitas
P(yt|yt− 1 ) terbesar.Bdisebut sebagaibeam- _width_. Algoritma _Beam Search_
bekerja dengan prinsip yang mirip denganbest-first search(best-Bsearch)
yang sudah kamu pelajari di kuliah algoritma atau pengenalan kecerdasan
buatan.^16 Pseudo-code _Beam Search_ diberikan pada Gambar. 13.20 (direct
quotation).
13.4.4 Attention-based Mechanism
Seperti yang sudah dijelaskan sebelumnya, model _encoder-decoder_ memiliki
masalah saat diberikan sekuens yang panjang ( _vanishing_ atau _exploding_ gradient
problem). Kinerja model dibandingkan dengan panjang _input_ kurang
lebih dapat diilustrasikan pada Gambar. 13.21. Secara sederhana, kinerja
_model_ menurun seiring sekuens input bertambah panjang. Selain itu, representasicyang
dihasilkan _encoder_ harus memuat informasi keseluruhan _input_ walaupun
sulit dilakukan. Ditambah lagi, _decoder_ menggunakan representasinyacsaja
tanpa boleh melihat bagian-bagian khusus _inputs_ aat _decoding_.
Hal ini tidak sesuai dengan cara kerja manusia, misalnya pada kasus
(^14) https://en.wikipedia.org/wiki/Beam_search
(^15) https://en.wikibooks.org/wiki/Artificial_Intelligence/Search/
Heuristic_search/Beam_search
(^16) https://www.youtube.com/watch?v=j1H3jAAGlEA&t=2131s
```
13.4 Sequence to Sequence 199
```
translasi bahasa. Ketika mentranslasi bahasa, manusia melihat bolak-balik
bagian mana yang sudah ditranslasi dan bagian mana yang sekarang (difokuskan)
untuk ditranslasi. Artinya, manusia berfokus pada suatu bagian
_input_ untuk menghasilkan suatu translasi.
```
Gambar 13.21: Permasalahan _input_ yang panjang.
```
Sudah dijelaskan sebelumnya bahwa representasi sekuens _input_ cadalah
sebuah _weighted sum_.cyang sama digunakan sebagai _input_ bagi _decoder_ untuk
menentukan semua _output_. Akan tetapi, untuk suatu tahapan _decoding_
(untuk _hidden state_ h′ttertentu), kita mungkin ingin model lebih berfokus
pada bagian _input_ tertentu daripada _weighted sum_ yang sifatnya generik. Ide
ini adalah hal yang mendasari _attention mechanism_ [57, 58]. Ide ini sangat
berguna pada banyak aplikasi pemrosesan bahasa alami. _Attention mechanism_ dapat
dikatakan sebagai suatu _soft alignment_ antara _input_ dan _output_.
Mekanisme ini dapat membantu mengatasi permasalahan _input_ yang panjang,
seperti diilustrasikan pada Gambar. 13.22.
Dengan menggunakan _attention mechanism_, kita dapat mentransformasi
persamaan 13.16 pada _decoder_ menjadi persamaan 13.17, dimanaktmerepresentasikan
seberapa ( _how much_ ) _decoder_ harus memfokuskan diri ke _hidden_
_state_ tertentu pada _encoder_ untuk menghasilkan _output_ saat ke-t.ktdapat
dihitung pada persamaan 13.18, dimanaTmerepresentasikan panjang _input_,
hiadalah _hidden state_ pada _encoder_ pada saat ke-i,h′t− 1 adalah _hidden state_
pada _decoder_ saat ket−1.
```
h′t=f′(h′t− 1 ,e′t− 1 ,c,kt) (13.17)
```
200 13 Arsitektur Neural Network
```
Gambar 13.22: Menggunakan vs tidak menggunakan _attention_.
```
```
kt=
```
#### ∑T
```
i=1
```
```
αt,ihi
```
```
αt,i=
```
```
exp(hi·h′t− 1 )
∑T
z=1exp(hz·h
```
```
′
t− 1 )
```
#### (13.18)
Sejatinyaktadalah sebuah _weighted sum_. Berbeda dengancyang bernilai
sama untuk setiap tahapan _decoding_, _weight_ atau bobot (αt,i) masingmasing
_hidden state_ pada encoder berbeda-beda untuk tahapan _decoding_
yang berbeda. Perhatikan Gambar. 13.23 sebagai ilustrasi (lagi-lagi, bentuk
_encoder-decoder_ yang disederhanakan). Terdapat suatu bagian grafik yang
menunjukkan distribusi bobot pada bagian _input representation_ dan _attention_.
Distribusi bobot pada _weighted sum_ cadalah pembobotan yang bersifat
generik, yaitu berguna untuk keseluruhan (rata-rata) kasus. Masing-masing
_attention_ (semacam _layers_ emu) memiliki distribusi bobot yang berbeda pada
tiap tahapan _decoding_. Walaupun _attention mechanism_ sekalipun tidak sempurna,
ide ini adalah salah satu penemuan yang sangat penting.
Seperti yang dijelaskan pada bab 11 bahwa _neural network_ susah untuk
dimengerti. _Attention mechanism_ adalah salah satu cara untuk mengerti _neural_
_network_. Contoh yang mungkin lebih mudah dipahami diberikan pada
Gambar. 13.24 yang merupakan contoh kasus mesin translasi [57].Attention
mechanismmampu mengetahui _soft alignment_, yaitu kata mana yang harus
difokuskan saat melakukan translasi bahasa (bagian _input_ mana berbobot
lebih tinggi). Dengan kata lain, _attention mechanism_ memberi interpretasi
kata pada _output_ berkorespondensi dengan kata pada _input_ yang mana. Sebagai
informasi, menemukan cara untuk memahami (interpretasi) ANN adalah
salah satu tren riset masa kini [56].
```
13.4 Sequence to Sequence 201
```
```
𝑥!
```
```
...
```
```
𝑥"
```
```
_Input_ Representation 𝒄
⨁
```
```
Attention
```
```
⨁
Attention
```
```
⨁
Attention
```
```
⨁
```
```
<EOS>
```
```
𝑦!
```
```
𝒄
```
```
𝑦#
```
```
...
```
```
𝒄
```
```
𝑦$%! 𝑦$
```
```
Gambar 13.23: _Encoder-decoder_ with attention.
```
Gambar 13.24: _Attention mechanism_ pada translasi bahasa [57]. Warna lebih
gelap merepresentasikan bobot (fokus/ _attention_ ) lebih tinggi. Sebagai contoh,
kata “menendang” berkorespondensi paling erat dengan kata “kicks”.
13.4.5 Variasi Arsitektur Sequence to Sequence
Selain RNN, kita juga dapat menggunakan _bidirectional_ RNN (BiRNN) untuk
mengikutsertakan pengaruh baik _hidden states_ ebelum (h 1 ,···,ht− 1 ) dan
setelah (ht+1,···,hT) untuk menghitung _hidden states_ ekarang (ht) [85, 86,
87]. BiRNN menganggaphtsebagai gabungan ( _concatenation_ ) _forward_ hidden
_state_ h→t dan _backward hidden state_ h←t , ditulis sebagaiht=h→t +h←t.^17
_Forward hidden state_ dihitung seperti RNN biasa yang sudah dijelaskan pada
subbab _encoder_, yaituh→t =f(h→t− 1 ,et). _Backward hidden state_ dihitung
dengan arah terbalikh←t =f(h←t+1,et). Ilustrasi _encoder-decoder_ yang menggunakan
BiRNN dapat dilihat pada Gambar. 13.25.
Selain variasi RNN menjadi BiRNN kita dapat menggunakan _stacked RNN_
seperti pada Gambar. 13.26 dimana _output_ pada RNN pertama bertindak
sebagai _input_ pada RNN kedua. _Hidden states_ yang digunakan untuk menghasilkan
representasi _encoding_ adalah RNN pada tumpukan paling atas. Kita
(^17) Perhatikan! + disini dapat diartikan sebagai penjumlahan atau konkatenasi
202 13 Arsitektur Neural Network
Gambar 13.25: _Encoder-decoder_ dengan Bidirectional Recurrent Neural Net-
work.
juga dapat menggunakan variasi _attention mechanism_ seperti _neural_ checklist
_model_ [88] atau _graph-based attention_ [89]. Selain yang disebutkan, masih
banyak variasi lain yang ada, silahkan eksplorasi lebih lanjut sendiri.
```
Gambar 13.26: _Encoder-decoder_ denganstackedRecurrent Neural Network.
```
13.4.6 Rangkuman
_Sequence to sequence_ adalah salah satu bentuk _conditioned generation_. Artinya,
menggunakan RNN untuk menghasilkan ( _generate_ ) suatu sekuens _output_ yang
dikondisikan oleh variabel tertentu. Diktat ini memberikan contoh bagaimana
menghasilkan suatu sekuens _output_ berdasarkan sekuens _input_ ( _conditioned_
```
13.6 Architecture Ablation 203
```
on a sequence of input). Selain _input_ berupa sekuens, konsep ini juga dapat
diaplikasikan pada bentuk lainnya. Misalnya, menghasilkan _caption_ saat input
yang diberikan adalah sebuah gambar [90]. Kita ubah _encoder_ menjadi sebuah
CNN (ingat kembali subbab 13.1) dan _decoder_ berupa RNN [90]. Gabungan
CNN-RNN tersebut dilatih bersama menggunakan metode _backpropagation_.
Perhatikan, walaupun memiliki kemiripan dengan _hidden markov model_,
_sequence to sequence_ bukanlah _generative model_. Pada _generative model_, kita
ingin me _model_ kan _joint probability_ p(x,y) =p(y|x)p(x) (walaupun secara
tidak langsung, misal menggunakan teori Bayes). _Sequence to sequence_ adalah
_discriminative model_ walaupun _output_ -nya berupa sekuens, ia tidak me _model_ kanp(x),
berbeda dengan _hidden markov model_. Kita ingin me _model_ kan
_conditional probability_ p(y|x) secara langsung, seperti _classifier_ lainnya (e.g.,
_logistic regression_ ). Jadi yang di _model_ kan antara _generative_ dandiscriminative
_model_ adalah dua hal yang berbeda.
Pada subbab ini, penulis memberikan contoh _attention mechanism_ yang
beroperasi antara _encoder_ dan _decoder_. Masih banyak variasi lainnya seperti
_self-attention_, _multi-head attention_ dan _hierarchical-attention_ [91, 92]. Walaupun
motivasi dan penggunaan variasi _attention mechanism_ berbeda-beda,
konsep dasarnya sama yaitu mengekstrak (atau mengambil) informasi dari
bagian _network_ lainnya.
|
### 13.1 Convolutional Neural Network
Subbab ini akan memaparkanide utamadari _convolutional neural network_
(CNN) berdasarkan _paper_ asli dari LeCun dan Bengio [76] (saat buku ini
ditulis sudah ada banyak variasi). CNN memiliki banyak istilah dari bidang
pemrosesan gambar (karena dicetuskan dari bidang tersebut), tetapi demi
182 13 Arsitektur Neural Network
mempermudah pemahaman intuisi CNN, diktat ini akan menggunakan istilah
yang lebih umum juga.
Sekarang, mari kita memasuki cerita CNN dari segi pemrosesan gambar.
Objek bisa saja terlatak pada berbagai macam posisi seperti diilustrasikan
oleh Gambar. 13.1. Selain tantangan variasi posisi objek, masih ada juga tantangan
lain seperti rotasi objek dan perbedaan ukuran objek ( _scaling_ ). Kita
ingin mengenali (memproses) objek pada gambar pada berbagai macam posisi
yang mungkin ( _translation invariance_ ). Salah satu cara yang mungkin
adalah dengan membuat suatu mesin pembelajaran (ANN) untuk regional
tertentu seperti pada Gambar. 13.2 (warna biru) kemudian meng- _copy_ mesin
pembelajaran untuk mampu mengenali objek pada regional-regional lainnya.
Akan tetapi, kemungkinan besar ANN _copy_ memiliki konfigurasi parameter
yang sama dengan ANN awal. Hal tersebut disebabkan objek memiliki
informasi prediktif (predictive information– _feature vector_ ) yang sama yang
berguna untuk menganalisisnya. Dengan kata lain, objek yang sama ( _smiley_ )
memiliki pola _feature vector_ yang mirip walaupun posisinya digeser-geser.
ANN (MLP) bisa juga mempelajari prinsip _translation invariance_, tetapi
memerlukan jauh lebih banyak parameter dibanding CNN (subbab berikutnya
secara lebih matematis) yang memang didesain dengan prinsiptranslation
in _variance_ (“ _built-in_ ”).
```
Gambar 13.1: Motivasi _convolutional neural network_.
```
13.1.1 Convolution
Seperti yang sudah dijelaskan, motivasi CNN adalah untuk mampu mengenali
aspek yang informatif pada regional tertentu (lokal). Dibanding meng _copy_ mesin
pembelajaran beberapa kali untuk mengenali objek pada banyak
regional, ide lebih baik adalah untuk menggunakan _sliding window_. Setiap
```
13.1 Convolutional Neural Network 183
```
```
Gambar 13.2: Motivasi _convolutional neural network_, solusi regional.
```
operasi pada _window_ ^1 bertujuan untuk mencari aspek lokal yang paling informatif.
Ilustrasi diberikan oleh Gambar. 13.3. Warna biru merepresentasikan
satu _window_, kemudian kotak ungu merepresentasikan aspek lokal paling informatif
(disebut _filter_ ) yang dikenali oleh _window_. Dengan kata lain, kita
mentransformasi suatu _window_ menjadi suatu nilai numerik ( _filter_ ). Kita juga
dapat mentransformasi suatu _window_ (regional) menjadidnilai numerik (d _channels_,
setiap elemen berkorespondensi pada suatu _filter_ ). _Window_ ini kemudian
digeser-geser sebanyakTkali, sehingga akhirnya kita mendapatkan
_vektor_ dengan panjangd×T. Keseluruhan operasi ini disebut sebagaicon-
volution.^2
```
Gambar 13.3:Sliding window.
```
Agar kamu lebih mudah memahami prinsip ini, kami berikan contoh dalam
bentuk 1-D pada Gambar. 13.4. Warna biru merepresentasikan _feature vector_
(regional) untuk suatu _input_ (e.g., regional pada suatu gambar, kata pada
kalimat, dsb). Pada contoh ini, setiap 2 _input_ ditransformasi menjadi vektor
berdimensi 2 (2- _channels_ ); menghasilkan vektor berdimensi 4 (2 _window_ ×
2).
Pada contoh sebelumnya, kita menggunakan _window_ selebar 2, satu _window_ mencakup
2 data lokal; i.e., _window_ 1 = (x 1 ,x 2 ), _window_ 2 = (x 2 ,x 3 ), ...
; untuk suatu _input x_. Kita juga dapat mempergunakan _stride_ sebesars,
(^1) Dikenal juga sebagai _receptive field_.
(^2) Istilah _convolution_ yang diterangkan pada konteks _machine learning_ memiliki arti
yang berbeda pada bidang _signal processing_.
184 13 Arsitektur Neural Network
```
Gambar 13.4:1D Convolution.
```
yaitu seberapa banyak data yang digeser untuk _window_ baru. Contoh yang
diberikan memiliki _stride_ sebesar satu. Apabila kita memiliki _stride_ =2, maka
kita menggeser sebanyak 2 data setiap langkah; i.e., _window_ 1 = (x 1 ,x 2 ), _window_
2 = (x 3 ,x 4 ),···.
Selain _sliding window_ dan _filter_, _convolutional layer_ juga mengadopsi prinsip _weight_
sharing. Artinya, _synapse weights_ untuk suatu filter adalah sama
walau _filter_ tersebut dipergunakan untuk berbagai _window_. Sebagai ilustrasi,
perhatikan Gambar. 13.5, warna yang sama pada _synapse weights_ menunjukkansynapse
_weight_ s bersangkutan memiliki nilai ( _weight_ ) yang sama.
Tidak hanya pada _filter_ hitam, hal serupa juga terjadi pada _filter_ berwarna
oranye (i.e., _filter_ berwarnya oranye juga memenuhi prinsip _weight sharing_ ).
Walaupun memiliki konfigurasi bobot _synapse weights_ yang sama, unit dapat
menghasilkan _output_ yang berbeda untuk _input_ yang berbeda. Konsep
_weight sharing_ ini sesuai dengan cerita sebelumnya bahwa konfigurasi parameter
untuk mengenali karakteristik informatif untuk satu objek bernilai sama
walau pada lokasi yang berbeda. Dengan _weight sharing_, parameter _neural_
_network_ juga menjadi lebih sedikit dibanding menggunakan _multilayer perceptron_ ( _feed-forward_
_neural network_ ).
```
Gambar 13.5: Konsep _weight sharing_.
```
13.1.2 Pooling
Pada tahap _convolution_, kita merubah setiap _k-sized window_ menjadi satu
_vektor_ berdimensid(yang dapat disusun menjadi matriksD). Semua vektor
yang dihasilkan pada tahap sebelumnya dikombinasikan ( _pooled_ ) menjadi
```
13.1 Convolutional Neural Network 185
```
satu vektorc. Ide utamanya adalah mengekstrak informasi paling informatif
(semacam meringkas). Ada beberapa teknik _pooling_, diantaranya: _max pooling_,
_average pooling_, dan _K-max pooling_ ;^3 diilustrasikan pada Gambar. 13.6.Max
_pooling_ mencari nilai maksimum untuk setiap dimensi vektor. _Average pooling_
mencari nilai rata-rata tiap dimensi. _K-max pooling_ mencariKnilai terbesar
untuk setiap dimensinya (kemudian hasilnya digabungkan). Gabungan operasi
_convolution_ dan _pooling_ secara konseptual diilustrasikan pada Gambar. 13.7.
```
Gambar 13.6: Contoh _pooling_.
```
Setelah melewati berbagai operasi convolution dan _pooling_, kita akan
memiliki satu vektor yang kemudian dilewatkan pada _multilayer perceptron_
( _fully connected_ ) untuk melakukan sesuatu (tergantung permasalahan), misal
klasifikasi gambar, klasifikasi sen _time_ n, dsb (Ilustrasi pada Gambar. 13.8).
13.1.3 Rangkuman
Kemampuan utama _convolutional neural network_ (CNN) adalah arsitektur
yang mampu mengenali informasi prediktif suatu objek (gambar, teks, potongan
suara, dsb) walaupun objek tersebut dapat diposisikan dimana saja
pada _input_. Kontribusi CNN adalah pada _convolution_ dan _pooling_ layer. _Convolution_ bekerja
dengan prinsip _sliding window_ dan _weight sharing_ (mengurangi
kompleksitas perhitungan). _Pooling layer_ berguna untuk merangkum
informasi informatif yang dihasilkan oleh suatu _convolution_ (mengurangi dimensi).
Pada ujung akhir CNN, kita lewatkan satu vektor hasil beberapa operasi _convolution_ dan _pooling_ padamulti _layer_
_perceptron_ ( _feed-forward_ neural
_network_ ), dikenal juga sebagai _fully connected layer_, untuk melakukan suatu
pekerjaan, e.g., klasifikasi. Perhatikan, pada umumnya CNN tidak berdiri
(^3) Kami ingin pembaca mengeksplorasi sendiri _dynamic pooling_.
186 13 Arsitektur Neural Network
```
Gambar 13.7: _Convolution_ dan _pooling_.
```
```
Gambar 13.8: _Convolution_ al Neural Network.^4
```
sendiri, dalam artian CNN biasanya digunakan (dikombinasikan) pada arsitektur
yang lebih besar.
|
### 12.2 Singular Value Decomposition
Sebelum masuk ke _autoencoder_ secara matematis, penulis akan memberikan
sedikit _overview_ tentang dekomposisi matriks. Seperti yang sudah dijelaskan
pada bab-bab sebelumnya, dataset dimana setiap _input_ direpresentasikan oleh
_feature vector_ dapat disusun menjadi matriksXberukuranN×F, dimanaN
adalah banyaknya sampel^4 danFadalah dimensi fitur. Pada _machine learning_,
dekomposisi atau reduksi dimensi sangat penting dilakukan terutama
ketika dataset berupa _sparse matrix_. Dekomposisi berkaitan erat denganprincipal
component analysis (PCA) yang sudah kamu pelajari. Teknik PCA
(melalui _eigendecomposition_ ) mendekomposisi sebuah matriksXmenjadi tiga
buah matriks, seperti diilustrasikan pada persamaan 12.1. MatriksAadalah
kumpulan eigenvector danλadalah sebuah diagonal matriks yang berisi nilai
eigenvalue, dimanaUberukuranN×N,VberukuranN×F, danWT
berukuranF×F.
X=AλA−^1 (12.1)
PCA membutuhkan matriks yang kamu ingin dekomposisi berbentu simetris.
Sedangkan, teknik _singular value decomposition_ (SVD) tidak. Dengan konsep
yang mirip dengna PCA, matriksXdapat difaktorisasi menjadi tiga buah matriks
menggunakan teknik SVD, dimana operasi ini berkaitan dengan mencari
eigenvectors, diilustrasikan pada persamaan 12.2.
```
X=U V WT (12.2)
```
(^4) Banyaknya training data.
166 12 Auto _encoder_
Perlu diperhatikan, matriksVadalah sebuah diagonal matriks (elemennya
adalah nilai _singular value_ dariX).Udisebut _left-singular vectors_ yang
tersusun atas eigenvector dariXXT. Sementara,Wdisebutright-singular
vectorsyang tersusun atas eigenvector dariXTX.
Misalkan kita mempunyai sebuah matriks lainVˆberukuranK×K, yaitu
modifikasi matriksVdengan mengganti sejumlah elemen diagonalnya menjadi
0 (analogi seperti menghapus beberapa baris dan kolom yang dianggap kurang
penting). Sebagai contoh, perhatikan ilustrasi berikut!
#### V=
####
####
####
####
```
α 1 0 0 0 0
0 α 2 0 0 0
0 0 α 3 0 0
0 0 0 α 40
```
####
####
####
####
#### Vˆ=
####
####
```
α 1 0 0
0 α 2 0
0 0α 3
```
####
####
Kita juga dapat me-nol-kan sejumlah baris dan kolom pada matriksUdan
WmenjadiUˆ(N×K) danWˆT(K×F). Apabila kita mengalikan semuanya,
kita akan mendapat matriksXˆyang merupakan _approximation_ untuk matriks
asliX, seperti diilustrasikan pada persamaan 12.3.
Xˆ=UˆVˆWˆT (12.3)
Suatu baris dari matriksE=Uˆ Vˆ dianggap sebagai aproksimasi baris
matriksXberdimensi tinggi [1]. Artinya, menghitung _dot-product_ Ei·Ej=
Xˆi·Xˆj. Artinya, operasi pada matriksEkurang lebih melambangkan operasi
pada matriks asli. Konsep ini menjadi fundamental _autoencoder_ yang akan
dibahas pada subbab berikutnya. Operasi data pada level _coding_ dianggap
merepresentasikan operasi pada bentuk aslinya. Matriks aproksimasi ini memanfaatkan
sejumlahKarah paling berpengaruh pada data. Dengan analogi
tersebut, sama seperti mentransformasi data ke bentuk lain dimana data hasil
transformasi memiliki varians yang tinggi.
|
### 12.1 Representation Learning
Pada bab model linear, kamu telah mempelajari ide untuk mentransformasi
_data_ menjadi dimensi lebih tinggi agar data tersebut menjadi _linearly separable_.
Pada bab ini, kamu mempelajari hal sebaliknya, yaitu mengurangi
dimensi. _Curse of dimensionality_ dapat dipahami secara mendalam apabila
kamu membaca buku [65]. Untuk melakukan klasifikasi maupun _clustering_,
kita membutuhkan fitur. Fitur tersebut haruslah dapat membedakan satu _instance_ dan _instance_ lainnya.
Seringkali, untuk membedakan _instance_ satu dan
164 12 Auto _encoder_
_instance_ lainnya, kita membutuhkan _feature vector_ yang berdimensi relatif
“besar”. Karena dimensi _feature vector_ besar, kita butuh sumber daya komputasi
yang besar juga (bab 9). Untuk itu, terdapat metode-metodefeature
selection^1 untuk memilih fitur-fitur yang dianggap “representatif” dibanding
fitur lainnya. Sayangnya, bila kita menggunakan metode-metodefeature
selectionini, tidak jarang kita kelihangan informasi yang memuat karakteristik
_data_. Dengan kata lain, ada karakteristik yang hilang saat menggunakan
_feature selection_.
Pertanyaan yang kita ingin jawab adalah apakah ada cara untuk merepresentasikan
_data_ ke dalam bentuk yang membutuhkan memori lebih sedikit
tanpa adanya kehilangan informasi? Kita dapat memanfaatkan prinsipprincipal
component analysisyang sudah kamu pelajari pada bab 9 untuk mereduksi
dimensi data (mengurangi dimensi _input_ ), pada saat yang bersamaan,
menjaga karakteristik data. _Representation learning_ adalah metode untuk
melakukankompresi _feature vector_ menggunakan _neural network_.^2 Proses
melakukan kompresi disebut _encoding_, hasil _feature vector_ dalam bentuk
terkompres disebut _coding_, proses mengembalikan hasil kompresi ke bentuk
awal disebut _decoding_.^3 Neural networkyang mampu melakukan proses _encoding_ disebut _encoder_,
sedangkan _decoder_ untuk proses _decoding_ [66, 67,
68, 69, 70].
```
Gambar 12.1: Contoh auto _encoder_ sederhana.
```
Contoh _representation learning_ paling sederhana kemungkinan besar adalah
_autoencoder_ yaitu _neural network_ yang dapat merepresentasikan data kemudian
merekonstruksinya kembali. Ilustrasi _autoencoder_ dapat dilihat pada
(^1) [http://scikit-learn.org/stable/modules/feature_selection.html](http://scikit-learn.org/stable/modules/feature_selection.html)
(^2) Istilah _representation learning_ pada umumnya mengacu dengan teknik menggunakan _neural_
_network_.
(^3) Bisa dianggap sebagai proses menginterpretasikan _coding_.
```
12.2 Singular Value Decomposition 165
```
Gambar 12.1. Karena tujuan _encoder_ untuk kompresi, bentuk terkompresi
haruslah memiliki dimensi lebih kecil dari dimensi _input_. _Neural network_
mampu melakukan “kompresi” dengan baik karena ia mampu menemukan
_hidden structure_ dari data. _Autoencoder_ dilatih untuk memilimalkan meminimalkan _loss_.
Kamu mungkin berpikir bahwa idealnya, _output_ harus sama
dengan _input_, yaitu _autoencoder_ dengan tingkat _loss_ 0%. Akan tetapi, kita
sebenarnya tidak ingin _autoencoder_ memiliki performa 100% (subbab 12.4).
Contoh klasik lainnya adalah _N-gram language modelling_, yaitu memprediksi
kataytdiberikan suatu konteks ( _surrounding words_ ) misal kata sebelumnyayt−
1 (bigram), i.e.,P(yt|yt− 1 ) Apabila kita mempunyai _vocabulary_ sebesar
40,000 berarti suatu bigram model membutuhkan _memory_ sebesar
40, 0002 (kombinatorial). Apabila kita ingin memprediksi kata diberikan
_history_ yang lebih panjang (misal dua kata sebelumnya– _trigram_ ) maka kita
membutuhkan _memory_ sebesar 40, 0003. Artinya, _memory_ yang dibutuhkan
berlipat secara eksponensial. Tetapi, terdapat st _rate_ gi menggunakan _neural_
_network_ dimana parameter yang dibutuhkan tidak berlipat secara eksponensial
walau kita ingin me _model_ kan konteks yang lebih besar [71].
|
### 12.3 Ide Dasar Auto _encoder_
Seperti yang sudah dijelaskan _autoencoder_ adalah _neural network_ yang mampu
merekonstruksi _input_. Ide dasar _autoencoder_ tidak jauh dari konsep dekomposisi/di _mention_ ality
reductionmenggunakan _singular value decomposition_.
Diberikan datasetX, kita ingin mensimulasikan pencarian matriksXˆ yang
merupakan sebuah aproksimasi dari matriks asli. Arsitektur dasar _autoencoder_
diberikan pada Gambar 12.1. Kita memberi input matriksXpada _autoencoder_,
kemudian ingin _autoencoder_ tersebut menghasilkan matriks yang sama.
Dengan kata lain, _desired output_ sama dengan _input_. Apabila dihubungkan
dengan pembahasan ANN pada bab sebelumnya, _error function_ untuk melatih
_autoencoder_ diberikan pada persamaan 12.4, dimanayadalah output dari
jaringan danZadalah dimensi _output_,Nadalah banyaknya sampel danxi
adalah data ke-i( _feature vector_ ke-i).
```
12.3 Ide Dasar Auto _encoder_ 167
```
```
E(θ) =
```
#### 1
#### N
#### ∑Z
```
i=j
```
#### (
```
xi[j]−yi[j]
```
#### ) 2
#### (12.4)
Persamaan 12.4 dapat kita tulis kembali sebagai persamaan 12.5, dimanaf
melambangkan fungsi aktivasi danθadalah ANN (kumpulan _weight_ matri-
ces).^5
```
E(θ) =
```
#### 1
#### N
#### ∑Z
```
j=1
```
#### (
```
xi[j]−f(xi,θ)[j]
```
#### ) 2
#### (12.5)
Seperti yang sudah dijelaskan sebelumnya, _desired output_ sama dengan _input_.
Tetapi seperti yang kamu ketahui, mencapai _loss_ sebesar 0% adalah hal yang
susah. Dengan demikian, kamu dapat memahami secara intuitif bahwa _autoencoder_ melakukan
aproksimasi terhadap data asli, tetapi tidak sama persis.
Apabila _loss_ sebesar 0%, ditakutkan bahwa _autoencoder_ semata-mata hanya
melakukan translasi (penggesaran) data saja. Gambar 12.2 mengilustrasikan
hubungan antara _autoencoder_ dan _singular value decomposition_.^6 Perhatikan,
ada dua proses _encoding_ yaitu merepresentasikan data ke dimensi lebih rendah
dan _decoding_ –rekonstruksi kembali.
```
_Input_
( _feature vector_ )
```
```
_Output_
(reconstruction of feature vector)
```
```
Coding
```
|
### 12.4 Resisting Perturbation
Pada subbab sebelumnya, telah dijelaskan bahwa mencapai performa 100%
(100% rekonstruksi) pada _autoencoder_ adalah hal yang tidak diinginkan. Hal
ini disebabkan karena kita ingin menghindari _autoencoder_ semata-mata hanya
mempelajari _trivial identity function_ [11], memiliki analogi denganone-toone
mapping. Misalnya, suatu gambar kuda dipetakan ke _coding_ c, kemudian
gambar kuda lainnya dipetakan ke _coding_ ˆc, danˆctidak mirip denganc, i.e.,
_cosine similarity_ -nya jauh. Artinya kita ingin _autoencoder_ merepresentasikan
dua hal yang mirip ke dalam bentuk representasi _coding_ yang mirip juga!
Walaupun kita ingin performa _autoencoder_ tidak mencapai 100%, tapi kita
masih ingin performanya dekat dengan 100%.
Tujuan utama _autoencoder_ adalah mengekstraksi informasi penting tentang
_data_ yang ada (seperti _principal components_ ), bukan replikasi semata.
Dengan alasan ini, _coding_ pada umumnya memiliki dimensi lebih rendah
dibanding _input_. Kita sebut arsitektur ini sebagai _undercomplete autoencoder_.
Apabila _coding_ memiliki dimensi lebih besar dari _input_, disebut sebagaiovercomplete
_autoencoder_ –yang kemungkinan besar hanya mempelajaritrivial
identity function[11]. Kita dapat menggunakan teknik regularisasi
pada _autoencoder_ untuk memastikan tujuan kita tercapai, misal
_sparse autoencoder_, _denoising autoencoder_ dan _penalizing derivaties_ [11]. Untuk
mengilustrasikan permasalahan, buku ini membahas _denoising autoencoder_ (silahkan
baca buku [11] untuk teknik regularisasi lainnya).
Diberikan suatu _input_ x, kemudian kita lakukan _noise-injection_ terhadap
_input_ tersebut, menghasilkan ̃x. Perhatikan Gambar 12.3, kita ingin _encoder_
memberikan bentuk _coding_ yang mirip bagixdan ̃x. Kita ingin memaksa _autoencoder_ untuk
mempelajari sebuah fungsi yang tidak berubah terlalu jauh
ketika _inputs_ edikit diubah. Hal ini disebut sebagai sifat _resistance to perturbation_.
Performa _autoencoder_ yang bernilai 100% berbahaya karena _autoencoder_ tersebut
belum tentu mampu mempelajari sifat data, melainkan
mampu “mengingat” _training data_ saja ( _mapping table_ ). Objektifdenoising
_autoencoder_ diberikan pada persamaan 12.9, yaitu kemampuan merekonstruksi
kembali data tanpa _noise_.
```
E(θ) =
```
#### 1
#### N
#### ∑Z
```
j=1
```
#### (
```
xi[j]−f( ̃xi,θ)[j]
```
#### ) 2
#### (12.9)
170 12 Auto _encoder_
```
Gambar 12.3:Resisting Perturbation.
```
Gambar 12.4: _Autoencoder_ yang memiliki sifat _resistance to perturbation_,
yaitu invarian terhadap sedikit perubahan.
```
Gambar 12.5:Mani _fold_ s.
```
Implikasi atau tujuan dari persamaan 12.9 diberikan pada Gambar 12.4
yang mengilustrasikan _invariant to slight changes_. Diberikan data dengan dis-
(^8) https://jaan.io/what-is-variational- _autoencoder_ -vae-tutorial/
```
12.5 Representing Context: Word Embedding 171
```
tribusi aslip _data_, dan data yang sudah terkena _noise_ ̃x, _autoencoder_ mampu
mengembalikan ̃xke bentuk aslix. Sebagai ilustrasi yang lebih “global”, perhatikan
Gambar 12.5 dimana suatu elips melambangkan _manifolds_, dimana
_data_ yang mirip (e.g., kuda dengan berbagai macam pose) berada pada ruang
yang cukup dekat satu sama lain. Kamu dapat memahamiresistance to
perturbationmembuat _autoencoder_ membentuk semacam “ruang lokal” yang
merepresentasikan suatu data dan variannya.
|
### CBOW Skip-gram
Gambar 12.8: CBOW ( _Continous bag of words_ ) vs Skip-gram, rekonstruksi
[49].
```
Si Kucingduduk ...tiker
```
```
Projection
(Embedding)
```
```
beralaskan
```
```
Gambar 12.9: CBOW.
```
```
12.5 Representing Context: Word Embedding 177
```
level abstrak, yaitu merepresentasikan kata dan konteksnya menjadi bentuk
_vektor_. Apabila kamu tertarik untuk memahami detilnya secara matematis,
kamu dapat membaca berbagai penelitian terkait.^14 Silahkan baca _paper_ oleh
Mikolov [48, 49] untuk detil implementasi _word embedding_.
12.5.4 Distributed Sentence Representation
Kita sudah dapat merepresentasikan kata menjadi vektor, selanjutnya kita
ingin mengonversi unit lebih besar (kalimat) menjadi vektor. Salah satu cara
paling mudah adalah menggunakan nilai rata-rata representasi _word embedding_ untuk
semua kata yang ada pada kalimat tersebut ( _average_ of its individual
_word embedding_ s). Cara ini sering digunakan pada bidang NLP dan cukup
_powerful_, sebagai contoh pada _paper_ oleh Putra dan Tokunaga [75]. Pada NLP,
sering kali kalimat diubah terlebih dahulu menjadi vektor sebelum dilewatkan
pada algoritma _machine learning_, misalnya untuk analisis sen _time_ n (kalimat
bersen _time_ n positif atau negatif). Vektor ini yang nantinya menjadifeature
vectorbagi algoritma _machine learning_.
Kamu sudah tahu bagaimana cara mengonversi kata menjadi vektor, untuk
mengonversi kalimat menjadi vektor cara sederhananya adalah merataratakan
nilai vektor kata-kata pada kalimat tersebut. Tetapi dengan cara
sederhana ini, sifat sekuensial dan _compositional_ pada kalimat tidak terpenuhi.
Sebagai contoh, kalimat “anjing menggigit Budi” dan “Budi menggigit
anjing” akan direpresentasikan sebagai vektor yang sama karena terdiri
dari kata-kata yang sama. Dengan demikian, representasi kalimat sederhana
dengan merata-ratakan vektor kata-katanya juga tidaklah sensitif terhadap
urutan.^15 Selain itu, rata-rata tidak sensitif terhadap _compositionality_. Misal
frase “bukan sebuah pengalaman baik” tersusun atas frase “bukan” yang diikuti
oleh “sebuah pengalaman baik”. Rata-rata tidak mengetahui bahwa
“bukan” adalah sebuah _modifier_ untuk sebuah frase dibelakangnya. Sen _time_ n
dapat berubah bergantung pada komposisi kata-katanya (contoh pada
Gambar 12.10).
Cara lainnya adalah meng- _encode_ kalimat sebagai _vektor_ menggunakan
_recursive autoencoder_. _Recursive_ berarti suatu bagian adalah komposisi dari
bagian lainnya. Penggunaan _recursive autoencoder_ sangat rasional berhubung
_data_ memenuhi sifat _compositionality_ yang direpresentasikan dengan baik oleh
topologi _recursive neural network_. Selain itu, urutan susunan kata-kata juga
tidak hilang. Untuk melatih _recursive autoencoder_, _output_ dari suatu layer
adalah rekonstruksi _input_, ilustrasi dapat dilihat pada Gambar 12.11. Pada
setiap langkah _recursive_, _hidden layer/coding layer_ berusaha men- _decode_ atau
merekonstruksi kembali vektor _input_.
Lebih jauh, untuk sen _time_ n analisis pada kata, kita dapat menambahkan
_output_ pada setiap _hidden layer_, yaitu sen _time_ n unit gabungan, seperti pada
(^14) Beberapa orang berpendapat bahwa _evil is in the detail_.
(^15) Karena ini _recurrent neural network_ bagus untuk _language modelling_.
(^16) [http://nlp.stanford.edu:8080/sen _time_ nt/rntnDemo.html](http://nlp.stanford.edu:8080/sen _time_ nt/rntnDemo.html)
178 12 Auto _encoder_
```
Gambar 12.10: Contoh analisis sen _time_ n (Stanford).^16
```
```
Gambar 12.11: Contoh recursive auto _encoder_.
```
Gambar 12.12. Selain menggunakan _recursive autoencoder_, kamu juga dapat
menggunakan _recurrent autoencoder_. Kami silahkan pada pembaca untuk
memahami _recurrent autoencoder_. Prinsipnya mirip dengan _recursive_ autoen-
coder.
Teknik yang disampaikan mampu mengonversi kalimat menjadi vektor,
lalu bagaimana dengan paragraf, satu dokumen, atau satu frasa saja? Teknik
umum untuk mengonversi teks menjadi vektor dapat dibaca pada [69] yang
lebih dikenal dengan nama _paragraph vector_ atau _doc2vec_.
```
12.6 Tips 179
```
```
Gambar 12.12: Contoh recursive auto _encoder_ dengan sen _time_ nt[67].
```
|
### 12.6 Tips
Bab ini menyampaikan penggunaan _neural network_ untuk melakukankompresi
_data_ ( _representation learning_ ) dengan teknik _unsupervised learning_. Hal
yang lebih penting untuk dipahami bahwa ilmu _machine learning_ tidak berdiri
sendiri. Walaupun kamu menguasai teknik machine learning tetapi tidak
mengerti domain dimana teknik tersebut diaplikasikan, kamu tidak akan bisa
membuat _learning machine_ yang memuaskan. Contohnya, pemilihan fiturmachine
_learning_ pada teks (NLP) berbeda dengan gambar ( _computer vision_ ).
Mengerti _machine learning_ tidak semata-mata membuat kita bisa menyelesaikan
semua macam permasalahan. Tanpa pengetahuan tentang domain aplikasi,
kita bagaikan orang buta yang ingin menyetir sendiri!
|
### Soal Latihan
12.1. Penggunaan Auto _encoder_ untuk Arsitektur Kompleks
(a) Pada bab ini, telah dijelaskan bahwa kita dapat menginisialisasi arsitektur
_neural network_ yang kompleks menggunakan _autoencoder_. Jelaskan pada
kasus apa kita dapat melakukan hal tersebut!
(b) Jelaskan mengapa menginisiasi (sebagian) arsitektur kompleks menggunakan _autoencoder_ adalah
sesuatu yang masuk akal!
12.2. LSI dan LDA
```
(a) Jelaskanlah Latent Semantic Indexing (LSI) dan Latent Dirichlet Allocation
(LDA)!
```
180 12 Auto _encoder_
(b) Apa persamaan dan perbedaan antara LSI, LDA, dan _autoencoder_ ?
12.3. Variational Auto _encoder_
Jelaskan apa itu _variational autoencoder_ ! Deskripsikan perbedaannya dengan
_autoencoder_ yang sudah dijelaskan pada bab ini?
|
### 12.5 Representing Context: Word Embedding
Subbab ini menceritakan salah satu aplikasi _autoencoder_. Pada domain NLP,
kita ingin komputer mampu mengerti bahasa selayaknya manusia mengerti
bahasa. Misalkan komputer mampu mengetahui bahwa “meja” dan “kursi”
memiliki hubungan yang erat. Hubungan seperti ini tidak dapat terlihat
berdasarkan teks tertulis, tetapi kita dapat menyusun kamus hubungan kata
seperti WordNet.^9 WordNet memuat ontologi kata seperti hipernim, antonim,
sinonim. Akan tetapi, hal seperti ini tentu sangat melelahkan, seumpama ada
kata baru, kita harus memikirkan bagaimana hubungan kata tersebut terhadap
seluruh kamus yang sudah dibuat. Pembuatan kamus ini memerlukan
kemampuan para ahli linguistik.
Oleh sebab itu, kita harus mencari cara lain untuk menemukan hubungan
kata ini. Ide utama untuk menemukan hubungan antarkata adalah _statistical_
semantics hypothesisyang menyebutkan pola penggunaan kata dapat
digunakan untuk menemukan arti kata [74]. Contoh sederhana, kata yang
muncul pada “konteks” yang sama cenderung memiliki makna yang sama.
Perhatikan “konteks” dalam artian NLP adalah kata-kata sekitar (surrounding
_word_ s);^10 contohnya kalimat “ _budi menendang bola_ ”, “konteks” dari “bola”
adalah “budi menendang”. Kata “cabai” dan “permen” pada kedua kalimat
“budi suka cabai” dan “budi suka permen” memiliki kaitan makna, dalam
artian keduanya muncul pada konteks yang sama. Sebagai manusia, kita tahu
ada keterkaitan antara “cabai” dan “permen” karena keduanya bisa dimakan.
Berdasarkan hipotesis tersebut, kita dapat mentransformasi kata menjadi
sebuah bentuk matematis dimana kata direpresentasikan oleh pola penggunaannya
[64]. Arti kata _embedding_ adalah transformasi kata (beserta konteksnya)
menjadi bentuk matematis ( _vektor_ ), i.e., mirip/sama dengan _coding_.
“Kedekatan hubungan makna” ( _semantic relationship_ ) antarkata kita
harapkan dapat tercermin pada operasi vektor. Salah satu metode sederhana
untuk merepresentasikan kata sebagai vektor adalahVector Space
Model. Konsep _embedding_ dan _autoencoder_ sangatlah dekat, tapi kami ingin
menakankan bahwa _embedding_ adalah bentuk representasi konteks.
(^9) https:// _word_ net.princeton.edu/
(^10) Selain _surrounding words_, konteks dalam artian NLP dapat juga berupa kalimat,
paragraph, atau dokumen.
172 12 Auto _encoder_
```
Dokumen 1 Dokumen 2 Dokumen 3 Dokumen 4···
King 1 0 0 0 ···
Queen 0 1 0 1 ···
Prince 1 0 1 0 ···
Princess 0 1 0 1 ···
···
```
```
Tabel 12.1: Contoh 1-of-V en _coding_.
```
_Semantic relationship_ dapat diartikan sebagai attributional atau
_relational similarity_. _Attributional similarity_ berarti dua kata memiliki
atribut/sifat yang sama, misalnya anjing dan serigala sama-sama berkaki empat,
menggongong, serta mirip secara fisiologis. _Relational similarity_ berarti
derajat korespondensi, misalnyaanjing:menggongongmemiliki hubungan
yang erat dengankucing:mengeong.
12.5.1 Vector Space Model
_Vector space model_ (VSM)^11 adalah bentuk _embedding_ yang relatif sudah
cukup lama tapi masih digunakan sampai saat ini. Pada pe _model_ an ini, kita
membuat sebuah matriks dimana baris melambangkan kata, kolom melambangkan
dokumen. Metode VSM ini selain mampu menangkap hubungan antarkata
juga mampu menangkap hubungan antardokumen ( _to some degree_ ).
Asal muasalnya adalah _statistical semantics hypothesis_. Tiap sel pada matriks
berisi nilai 1 atau 0. 1 apabilakataimuncul didokumenidan 0 apabila tidak.
Model ini disebut _1-of-V/1-hot encoding_ dimanaV adalah ukuran kosa
kata. Ilustrasi dapat dilihat pada Tabel 12.1.
Akan tetapi, _1-of-V encoding_ tidak menyediakan banyak informasi untuk
kita. Dibanding sangat ekstrim saat mengisi sel dengan nilai 1 atau 0 saja, kita
dapat mengisi sel dengan frekuensi kemunculan kata pada dokumen, disebut
_term frequency_ (TF). Apabila suatu kata muncul pada banyak dokumen,
kata tersebut relatif tidak terlalu ”penting” karena muncul dalam berbagai
konteks dan tidak mampu membedakan hubungan dokumen satu dan dokumen
lainnya ( _inverse document frequency_ /IDF). Formula IDF diberikan
pada persamaan 12.10. Tingkat kepentingan kata berbanding terbalik dengan
jumlah dokumen dimana kata tersebut dimuat.Nadalah banyaknya dokumen,|dD;td|adalah
banyaknya dokumen dimana katatmuncul.
```
IDF(t,D) = log
```
#### (
#### N
```
|dD;td|
```
#### )
#### (12.10)
Dengan menggunakan perhitungan TF-IDF yaituTF×IDFuntuk mengisi
sel pada matriks Tabel 12.1, kita memiliki lebih banyak informasi. TF-IDF
(^11) Mohon bedakan dengan VSM ( _vector space model_ ) dan SVM ( _support vector_
machine)
```
12.5 Representing Context: Word Embedding 173
```
sampai sekarang menjadi _baseline_ pada _information retrieval_. Misalkan
kita ingin menghitung kedekatan hubungan antar dua dokumen, kita hitung
_cosine distance_ antara kedua dokumen tersebut ( _vektor_ suatu dokumen
disusun oleh kolom pada matriks). Apabila kita ingin menghitung kedekatan
hubungan antar dua kata, kita hitung _cosine distance_ antara kedua kata tersebut
dimana vektor suatu kata merupakan baris pada matriks. Tetapi seperti
intuisi yang mungkin kamu miliki, mengisi _entry_ dengan nilai TF-IDF pun
akan menghasilkan _sparse matrix_.
```
_Statistical semantics hypothesis_ diturunkan lagi menjadi empat macam
hipotesis [74]:
1. _Bag of words_
2. _Distributional hypothesis_
3. _Extended distributional hypothesis_
4. _Latent relation hypothesis_
Silakan pembaca mencari sumber tersendiri untuk mengerti keempat hipotesis
tersebut atau membaca _paper_ Turney dan Pantel [74].
```
12.5.2 Sequential, Time Series dan Compositionality
Bahasa manusia memiliki dua macam karakteristik yaitu adalah data berbentuk _sequential_
_data_ dan memenuhi sifat _compositionality_. _Sequential data_
adalah sifat data dimana suatu kemunculan _data_ idipengaruhi oleh data sebelumnya
( _data_ i− 1 , _data_ i− 2 ,...). Perhatikan kedua kalimat berikut:
1. Budi melempar bola.
2. Budi melempar gedung bertingkat.
Pada kedua kalimat tersebut, kalimat pertama lebih masuk akal karena
bagaimana mungkin seseorang bisa melempar gedung bertingkat. Keputusan
kita dalam memilih kata berikutnya dipengaruhi oleh kata-kata sebelumnya,
dalam hal ini “Budi melempar” setelah itu yang lebih masuk akal adalah
“bola”. Contoh lain adalah data yang memiliki sifat _time series_ yaitu gelombang
laut, angin, dan cuaca. Kita ingin memprediksi data dengan rekaman
masa lalu, tapi kita tidak mengetahui masa depan. Kita mampu memprediksi
cuaca berdasarkan rekaman parameter cuaca pada hari-hari sebelumnya.
Ada yang berpendapat beda _time series_ dan _sequential_ (sekuensial) adalah
diketahuinya sekuens kedepan secara penuh atau tidak. Penulis tidak dapat
menyebutkan _time series_ dan sekuensial sama atau beda, silahkan pembaca
menginterpretasikan secara bijaksana.
Data yang memenuhi sifat _compositionality_ berarti memiliki struktur
hirarkis. Struktur hirarkis ini menggambarkan bagaimana unit-unit lebih kecil
berinteraksi sebagai satu kesatuan. Artinya, interpretasi/pemaknaan unit
yang lebih besar dipengaruhi oleh interpretasi/pemaknaan unit lebih kecil
174 12 Auto _encoder_
(subunit). Sebagai contoh, kalimat “saya tidak suka makan cabai hijau”. Unit
”cabai” dan ”hijau” membentuk suatu frasa ”cabai hijau”. Mereka tidak bisa
dihilangkan sebagai satu kesatuan makna. Kemudian interaksi ini naik lagi
menjadi kegiatan “makan cabai hijau” dengan keterangan “tidak suka”, bahwa
ada seseorang yang “tidak suka makan cabai hijau” yaitu “saya”. Pemecahan
kalimat menjadi struktur hirarkis berdasarkan _syntactical role_ disebutconstituent
parsing, contoh lebih jelas pada Gambar 12.6.Nadalah _noun_,D
adalah _determiner_,NPadalah _noun phrase_,VPadalah _verb phrase_, danS
adalah _sentence_. Selain bahasa manusia, gambar juga memiliki struktur hirarkis.
Sebagai contoh, gambar rumah tersusun atas tembok, atap, jendela,
dan pintu. Tembok, pintu, dan jendela membentuk bagian bawah rumah; lalu
digabung dengan atap sehingga membentuk satu kesatuan rumah.
```
Gambar 12.6: Contoh constituent tree.^12
```
12.5.3 Distributed Word Representation
Seperti yang disebutkan pada bagian sebelumnya, kita ingin hubungan kata
(yang di _infer_ ensi dari konteksnya) dapat direpresentasikan sebagai operasi
_vektor_ seperti pada ilustrasi Gambar 12.7. Kata “raja” memiliki sifat-sifat
yang dilambangkan oleh suatu vektor (misal 90% aspek loyalitas, 80% kebijaksanaan,
90% aspek kebangsaan, dst), begitu pula dengan kata “pria”,
“wanita”, dan “ratu”. Jika sifat-sifat yang dimiliki “raja” dihilangkan bagian
sifat-sifat “pria”-nya, kemudian ditambahkan sifat-sifat “wanita” maka idealnya
operasi ini menghasilkan vektor yang dekat kaitannya dengan “ratu”. Dengan
kata lain, raja yang tidak maskulin tetapi fenimin disebut ratu. Seperti
yang disebutkan sebelumnya, ini adalah tujuan utama _embedding_ yaitu merepresentasikan
“makna” kata sebagai vektor sehingga kita dapat memanipulasi
banyak hal berdasarkan operasi vektor. Hal ini mirip (tetapi tidak sama)
(^12) source: Pinterest
```
12.5 Representing Context: Word Embedding 175
```
dengan prinsip _singular value decomposition_ dan _autoencoder_ yang telah dijelaskan
sebelumnya.
```
Gambar 12.7: Contoh operasi vektor kata.
```
Selain _vector space model_, apakah ada cara lain yang mampu merepresentasikan
kata dengan lebih baik? Salah satu kekurangan VSM adalah
tidak memadukan sifat sekuensial pada konstruksi vektornya. Cara lebih baik
d _item_ ukan oleh [48, 49] dengan ekstensi pada [70]. Idenya adalah menggunakan
teknik _representation learning_ dan prinsip _statistical semantics hypothesis_.
Metode ini lebih dikenal dengan sebutan _word_ 2 vec. Tujuan _word_ 2 vec
masih sama, yaitu merepresentasikan kata sebagai vektor, sehingga kita dapat
melakukan operasi matematis terhadap kata. _Encoder_ -nya berbentukContinous
bag of words(CBOW)atauSkip-gram. Pada CBOW, kita memprediksi
kata diberikan suatu “konteks”. Pada arsitektur ”Skip-gram” kita
memprediksi konteks, diberikan suatu kata. Ilustrasi dapat dilihat pada Gambar
12.8. Bagian _projection layer_ pada Gambar 12.8 adalah _coding_ layer. Kami
akan memberikan contoh CBOW secara lebih detil. Kedua arsitektur ini dapat
dilatih menggunakan _one-hot encoding_, i.e.,wimerepresentasikanone-hot
_encoding_ untuk kata ke-i.
Perhatikan Gambar 12.9. Diberikan sebuah konteks “si kucing duduk ...
tiker”. Kita harus menebak apa kata pada “...” tersebut. Dengan menggunakan
teknik _autoencoder_, _output layer_ adalah distribusi probabili _task_ atai
pada konteks tersebut. Kata yang menjadi jawaban adalah kata dengan probabilitas
terbesar, misalkan pada kasus ini adalah “beralaskan”. Dengan arsitektur
ini, prinsip sekuensial atau _time series_ dan _statistical semantics hypothesis_
terpenuhi ( _to a certain extent_ ). Teknik ini adalah salah satu contoh penggunaan _neural_
_network_ untuk _unsupervised learning_. Kita tidak perlu mengkorespondensikan
kata dan _output_ yang sesuai karena _input vektor_ didapat dari
statistik penggunaan kata. Agar lebih tahu kegunaan vektor kata, kamu dapat
mencoba kode dengan bahasa pemrograman Python 2.7 yang disediakan
penulis.^13 Buku ini telah menjelaskan ide konseptual _word embedding_ pada
(^13) https://github.com/wiragotama/GloVe_Playground
176 12 Auto _encoder_
```
𝑤!"#
```
```
𝑤!$%
```
```
𝑤!"%
```
```
𝑤!$#
```
```
𝑤!
```
```
Weighted
Sum
```
```
INPUT OUTPUT
```
```
𝑤!
```
```
𝑤!"#
```
```
𝑤!$%
```
```
𝑤!"%
```
```
𝑤!$#
```
```
Projection
(Representation)
```
```
INPUT OUTPUT
```
|
### 9.3 Feature Selection
Pada pembelajaran mesin, pada umumnya kita menggunakan banyak (lebih
dari satu) fitur. Artinya kita merepresentasikan setiap _record_ ( _instance_ ) atau
_inputs_ ebagai suatu vektorx∈R^1 ×F; dimanaFmelambangkan dimensi vektor
atau banyaknya fitur. Seringkali,F bernilai besar sehingga model yang
kita miliki kompleks. Kita tentunya ingin mengurangi kompleksitas dengan
(^1) Curse of Dimensionality
```
9.3 Feature Selection 119
```
alasan-alasan yang sudah disebutkan pada subbab 9.2. Alasan lainnya karena
belum tentu semua fitur berguna. Cara termudah adalah dengan menghapus
fitur yang memiliki nilai varians = 0. Sayang sekali, hal ini tidak selalu terjadi.
Subbab ini membahas teknik-teknik yang dapat digunakan untuk menyederhanakan
fitur (mengurangi dimensi input).
9.3.1 Subset Selection (Feature Ablation)
Cara paling intuitif untuk mencari tahu kombinasi fitur terbaik adalah dengan
mencoba seluruh kombinasi fitur. Misal kita mempunyai fitur sebanyakF, kita
bisa pilih untuk menggunakan atau tidak menggunakan masing-masing fitur,
menghasilkan kombinasi sebanyak 2F. Dari keseluruhan kombinasi tersebut,
kita pilih suatu kombinasi fitur yang memerikan kinerja terbaik. Akan tetapi,
metode _brute force_ ini terlalu memakan waktu. Kita dapat juga menggunakan
teknik _greedy_ yaitu _forward selection_ dan _backward selection_.Forwarddan
_backward selection_ sering juga disebut sebagai _feature ablation_.
Pada _forward selection_, kita mulai dengan suatu model yang tidak menggunakan
fitur apapun sama sekali, yaitu meng- _assign_ kelas yang paling sering
muncul di dataset, pada _input_. Setelah itu, kita tambahkan satu per satu fitur
pada setiap langkah. Langkah berikutnya, kita gunakan satu fitur. DiantaraF
pilihan fitur, kita cari fitur yang memberi nilai terbaik. Kemudian, pada tahap
berikutnya, kita kombinasikan fitur yang kita pilih pada langkah sebelumnya
dengan fitur yang tersisa. Hal ini terus diulang sampai kita sudah menggunakan
seluruh fitur pada model kita. Untuk mencari model terbaik, kita hanya
perlu mencari kombinasi fitur yang memberikan nilai kinerja terbaik.Forward
selectiondiilustrasikan pada Gambar 9.1. Dibanding _brute force_ yang bersifat
eksponensial, _forward selection_ membentuk suatu deret aritmatika kombinasi
fitur yang dicoba, yaituF+ (F−1) +···+ 1 =F(F+ 1)/2. Apabila kita
memiliki fitur sebanyakF = 10, kombinasi _brute force_ menghasilkan 1, 024
kombinasi, sementara _forward selection_ hanya sebanyak 45.
```
Gambar 9.1: Ilustrasi _forward selection_ untuk tiga fitur.
```
_Backward selection_ adalah kebalikan dari _forward selection_. Apabila pada
_forward selection_, kita menambahkan satu fitur tiap langkah, _backward_ selec-
120 9 Seleksi Fitur dan Metode Evaluasi
tionmengurangi satu fitur pada tiap langkah. Ilustrasi diberikan pada Gambar
9.2. Seperti _forward selection_, _backward selection_ juga hanya mencoba sebanyakF(F+
1)/2 kombinasi. Kita juga dapat menggabungkan _forward_ dan
_backward selection_ menjadi metode _hybrid_, yaitu menambah satu fitur pada
tiap langkah, serta memperbolehkan untuk menghilangkan fitur juga [20].
```
Gambar 9.2: Ilustrasi _backward selection_ untuk tiga fitur.
```
9.3.2 Shrinkage
Ingat kembali materi bab 5 tentang _regularization_. Seperti yang sudah dijelaskan,
kita ingin agar model kita sesederhana mungkin. Mengurangi dimensi
fitur adalah cara mengurangi kompleksitas. Ingat kembali, dengan menggunakan
suatu fungsi regularisasi, objektif pembelajaran adalah meminimalkan
_loss_ dan kompleksitas, seperti pada persamaan 9.1. Kompleksitas model dapat
dihitung menggunakanL 2 (Ridge, persamaan 9.2) atauL 1 (Lasso, persamaan
9.3) norm. Karena kita ingin meminimalkan norm, artinya kita juga
membuat parameter model pembelajaran mesin bernilai dekat dengan nol.
Pada metode Ridge, kita ingin meminimalkan fungsi eksponensial, sementara
fungsi skalar pada Lasso. Artinya, Lasso lebih cenderung untuk menghasilkan
suatu model yang bersifat _sparse_. Dengan kata lain, Lasso melakukansubset
_feature selection_ seperti yang sudah dijelaskan pada subbab sebelumnya.
Sementara itu, Ridge cenderung tidak meng-nol-kan parameter, melainkan
hanyadekatdengan nol [20]. Kamu mungkin berpikir, kenapa kita tidak
menggunakan Lasso saja, berhubung ia mengeleminasi fitur. Pada metode
Ridge, semua fitur tetap digunakan walaupun nilainya diturunkan ( _shrink_ )
agar dekat dengan nol. Hal ini, walaupun tidak mengeleminasi fitur, dapat
mengurangi variasi kinerja model.^2 (dijelaskan pada subbab 9.5)
```
wˆ= arg min
w
```
```
L(w) +λR(w) (9.1)
```
```
R(w) =‖w‖^22 =
```
#### ∑
```
i
```
```
(wi)^2 (9.2)
```
(^2) baca buku [20] untuk pembuktiannya
```
9.3 Feature Selection 121
```
```
R(w) =‖w‖=
```
#### ∑
```
i
```
```
|wi| (9.3)
```
Secara singkat, Ridge digunakan untuk menghasilkan model yang varian
kinerjanya kecil. Sementara itu, Lasso digunakan untuk menghasilkan model
yang mudah dimengerti ( _interpretability_ ) dengan mengeliminasi fitur.
9.3.3 Principal Components Analysis (Dimensionality Reduction)
Teknik-teknik sebelumnya berfokus pada cara mengeleminasi fitur. Akan
tetapi, penghapusan suatu fitur berpotensi pada model yang tidak mampu
mengerti kompleksitas permasalahan. Dengan kata lain, _oversimplification_.
Dibanding menghapus fitur, cara lain untuk mengurangi kompleksitas komputasi
adalah mentransformasi data ke dalam dimensi lebih kecil. Untuk _input_
yang memilikiFfitur, kita kurangi dimensi _input_ menjadiM < F(dimensionality
reduction). Apabila kita mampu mengurangi dimensi _input_, maka kita
juga dapat mengurangi jumlah parameter pada model pembelajaran mesin,
yang artinya mengurangi kompleksitas komputasi dan meningkatkaninter-
pretability.
Ide utama _dimensionality reduction_ adalah mentransformasi data dari suatu _space_ ke _space_
lainnya, dimana data direpresentasikan dengan dimensi
lebih kecil. Dengan catatan, data dengan dimensi lebih kecil harus mampu
merepresentasikan karakteristik data pada dimensi aslinya! Dengan demikian,
satu fitur pada dimensi yang baru mungkin memuat informasi beberapa fitur
pada dimensi aslinya. Walaupun model yang kita hasilkan lebih sederhana
secara jumlah parameter, tetapi kita membutuhkan usaha ekstra untuk
mengerti representasi fitur-fitur pada dimensi yang baru.
Teknik yang digunakan untuk mengurangi dimensi adalahprincipal component
analysis. Ide dasarnya adalah mencari bentuk data (pada dimensi
lebih kecil) yang memiliki nilai varians tinggi untuk tiap fiturnya, karena
varians yang tinggi berarti kemampuan fitur yang tinggi dalam melakukan
diskriminasi (klasifikasi). Kita ingin mencari suatu arah ( _vektor_, matriks, tensor)
dimana data kita memiliki varians tertinggi. Pada dimensi yang baru,
kita berharap data kita tersebar menjadi beberapa kelompok yang mudah
dibedakan ( _easily separable_ ). Arah ini dikenal sebagaieigenvector, dan nilai
varians pada arah tersebut dikenal sebagaieigenvalue. Kami harap kamu
ingat materi kuliah aljabar linear. Eigenvector yang memiliki nilai eigenvalue
tertinggi disebut sebagai _principal components_, yaitu semacam bentuk
_data_ yang ringkas. Selain mengurangi dimensi, teknik ini juga mengurangi
(atau meniadakan) interaksi antar-fitur. Dengan demikian, kita dapat menggunakanadditive
assumptionsaat melakukan pembelajaran (ingat kembali
materi bab 5).
Saat melakukan analisis ini, kita membuat suatu asumsi bahwa sejumlah
_principal components_ cukup untuk merepresentasikan variasi yang ada pada
_data_ [20]. Dengan kata lain, kita mengasumsikan arah (eigenvector) ketika
122 9 Seleksi Fitur dan Metode Evaluasi
_data_ memiliki varians tertinggi, adalah arah yang berasosiasi dengan _output_.
_Singular Value Decomposition_ adalah salah satu teknik untuk melakukanprincipal
component analysis. Hal tersebut akan dibahas pada bab 12. Buku ini
juga akan memberi contoh konkret _dimensionality reduction_ denganartificial
_neural network_ pada bab 12.
|
### 9.6 Replicability, Overclaiming dan Domain Dependence
Pada dunia pembelajaran mesin, _replicability_ adalah hal yang sangat penting.
Artinya, eksperimen yang kamu lakukan dapat diulangi kembali oleh orang
lain, serta mendapat kinerja yang kurang lebih sama. Untuk ini, biasanya
_dataset_ dipublikasi pada domain publik agar dapat digunakan oleh banyak
orang, atau mempublikasi kode program. Selain _replicability_, kamu juga harus
memperhatikan _overclaiming_. Banyak orang yang menggunakan _toy dataset_
(berukuran sangat kecil) yang tidak merepresentasikan permasalahan aslinya.
Akan tetapi, mereka mengklaim bahwa model mereka memiliki generalisasi
yang baik. Kamu harus menginterpretasikan kinerja model secara bijaksana.
Kinerja yang baik pada _toy dataset_ belum tentu berarti kinerja yang baik
pada dunia nyata. Sebagai contoh, artikel yang dibahas pada _post_ ^4 ini adalah
contoh _overclaiming_.
Perlu kamu perhatikan juga, mendapatkan kinerja yang bagus pada suatu
_dataset_ belum tentu berarti model yang sama dapat mencapai kinerja yang
baik pada dataset lainnya. Misalnya, model yang dilatih untuk mengklasifikasikan
kategori berita belum tentu dapat mengklasifikasikan laporan medis.
Hal ini banyak terjadi pada _supervised learning_ [40]. Selain itu, kamu harus
memperhatikan karakteristik _performance metric_ yang digunakan agar tidak
salah menginterpretasikan kualitas model.
|
### 9.1 Feature Engineering
Record ( _data_ ) pada pembelajaran mesin pada umumnya dikonversi menjadi
suatu vektor ( _feature vector_ ) yang merepresentasikannya dalam bentuk
matematis. Fitur-fitur biasanya tersusun atas atribut yang kita anggap
memiliki pengaruh terhadap _output_. Sebagai contoh, tekanan darah diprediksi
berdasarkan usia, jenis kelamin dan BMI. Seringkali, seseorang membutuhkan
keahlian suatu bidang agar dapat memilih fitur yang tepat. Proses untuk
mencari (atau me-list) kandidat fitur, disebut sebagai aktivitasfeature en-
gineering.
Seperti kata mutiara yang kami berikan pada awal bab ini, kunci pembelajaran
mesin adalah representasi permasalahan. Fitur yang dipilih untuk
merepresentasikan data adalah bagaimana cara kamu merepresentasikan
masalah juga. Karena membutuhkan tingkat keahlian tertentu, proses memilih
fitur tidaklah mudah. Bisa jadi (sering), orang memilih fitur yang tidak representatif!
Dengan demikian, tidak heran apabila seseorang mempublikasikan
makalah ilmiah atas kontribusinya menentukan fitur baru pada domain ter-
tentu.
118 9 Seleksi Fitur dan Metode Evaluasi
Konon tetapi, proses pemilihan fitur yang bersifat manual ini cukup bahaya
karena rentan dengan _bias_, yaitu kemampuan seseorang pada domain
tertentu. Alangkah baiknya, apabila kita dapat memilih fitur yang memang
benar-benar diperlukan (murni) secara otomatis. Hal tersebut akan dibahas
lebih lanjut pada materi _artificial neural network_. Hal ini salah satu alasan
yang membuatnya populer.
|
### Soal Latihan
9.1. Seleksi Fitur
Jelaskanlah algoritma seleksi fitur selain yang sudah dijelaskan pada bab ini!
(Saran: baca _survey paper_ )
(^4) Pranala Post Yoav Goldberg
```
9.6 Replicability, Overclaiming dan Domain Dependence 133
```
9.2. AIC dan BIC
Jelaskan _Akaike Information Criterion_ (AIC) danBayesian Information Cri-
terion(BIC)!
9.3. AUC
Jelaskan _Area Under Curve_ (AUC)!
9.4. Dependency Parsing
Salah satu permasalahan penting pada bidang pemrosesan bahasa alami
adalah _dependency parsing_, dimana kita ingin memprediksi hubungan antar
kata pada suatu kalimat. Permasalahan ini sangatlah baik untuk mengilustrasikan
_model_ yang memprediksi _output_ berupa graph. Bacalah paper oleh
Kipperwasser dan Goldberg [39] tentang cara mereka me _model_ kan persoalan
tersebut dan jelaskan pada temanmu. Apakah evaluasi yang mereka lakukan
sudah cukup?
9.5. Bootstrapping
Jelaskan apa itu teknik _bootstrapping_ (evaluasi model)! Bagaimana perbedaanya _bootstrapping_ dancross
_validation_ ?
9.6. Varians
Jelaskan mengapa fitur yang baik memiliki varians yang tinggi, sementara
kinerja model yang baik memiliki varians yang rendah!
|
### 9.5 Cross Validation
Ingat kembali materi bab-bab sebelumnya bahwa pada umumnya kita membagi
_dataset_ menjadi tiga kelompok: _training_, _validation/development_ dan
130 9 Seleksi Fitur dan Metode Evaluasi
_testing_. Melatih dan mengukur kinerja model menggunakan training data
adalah hal yang tidak bijaksana karena kita tidak dapat mengetahui kemampuan
generalisasi model. Kita melatih model pembelajaran mesin menggunakan _training_
_data_ yang dievaluasi kinerjanya (saattraning) menggunakan
_validation data_. Setelah itu, kita uji model kembali menggunakan _testing data_.
Pada umumnya, ketiga kelompok tersebut memiliki data dengan karakteristik
yang sama. Artinya, dataset disampel dari distribusi yang sama. Misal pada
_training data_, ada pembagian 30:30:40 untuk data kelas pertama, kedua dan
ketiga. Distribusi persebaran tersebut juga harus sama pada _validation_ dan
_testing data_. Hal penting yang harus diperhatikan adalah tidak boleh ada data
yang sama ( _overlap_ ) pada ketiga kelompok tersebut.
Gambar 9.7: Model yang stabil (a) memberikan _decision boundary_ (garis hitam)
yang serupa walaupun _inputs_ edikit diubah-ubah (variasi kinerja yang
kecil, untuk set _input_ yang berbeda). Model yang kurang stabil (b) memberikandecision
boundary yang berbeda untuk _input_ yang sedikit diubahubah
(variasi kinerja yang besar, untuk set _input_ yang berbeda).
Pada dunia nyata, kita belum tentu memiliki ketiga kelompok tersebut.
Penyebabnya ada banyak, misal dataset yang kecil (hanya memiliki sedikit
_records_ ) atau pengadaan _testing data_ mahal. Apabila kita tidak memiliki _testing_
_data_, _validation data_ dapat menjadi pengganti ( _proxy_ ).
Akan tetapi, permasalahan _statistical bias_ dapat terjadi apabila kita hanya
menguji model pada satu set data karena kita tidak mengetahui variasi kinerja
_model_ [20]. Sebisanya, kita ingin mengevaluasi kinerja model pada beberapa
_dataset_, dan mengevaluasi variasi kinerja model. Kegiatan semacam
ini membuat kita mengetahui apakah suatu model cukup stabil^3 dan fleksi-
(^3) https://en.wikipedia.org/wiki/Stability_( _learning_ _theory)
```
9.5 Cross Validation 131
```
bel. Stabil berarti kinerja model tidak begitu berubah, diberikan _input_ yang
sedikit berubah (ilustrasi diberikan pada Gambar 9.7). Fleksibel berarti model
yang mampu menangkap karakteristik data dengan baik. Misal kita menggunakan
_model linear_ dengan persamaan polinomial orde-1, orde-2 dan orde-3.
Saat kita menaikkan orde persamaan sampai dengan orde-3, kinerja model
terus meningkat pada _validation_ data, walaupun kurang lebih sama pada
_training data_. Lalu, kita mencoba menggunakan persamaan polinomial orde-4,
dan kinerja model menurun pada _validation_ data. Artinya, persamaan polinomial
orde-3 adalah yang paling optimal untuk me _model_ kan permasalahan
yang kita miliki. Apabila kita tidak memiliki _validation_ data, kita tidak akan
mengetahui hal ini. Stabil berkaitan dengan nilai varians, sedangkan fleksibel
berkaitan dengan perubahan terhadap ukuran kinerja. Fleksibilitas dapat
dianalisis dengan mem- _plot_ grafik kinerja model pada _training data_ dan _validation_ / _testing_
_data_ untuk mengetahui _underfitting_ dan _overfitting_ seperti
yang sudah dijelaskan pada bab 5.
```
1 2 3 ... N
```
```
Fold 1
```
```
Fold 2
```
```
Fold 3
Fold 4
```
```
Fold 5
```
```
_Training_ data Validation data
```
Gambar 9.8: Ilustrasi 5- _fold-cross-validation_. Kotak berwarna merah melambangkan
subset yang dipilih sebagai _validation data_.
Kita dapat menganalisis stabilitas dengan menggunakan teknik cross
_validation_ seperti yang sudah dijelaskan pada bab 3. Intinya adalah, kita
membagi-bagi _dataset_ yang kita miliki menjadiKbagian. Kita latih model
menggunakanK−1 bagian, kemudian menguji prediksi model pada satu
bagian lainnya (sebagai _validation data_ ) yang mengaproksimasi kinerja pada
_testing data_ (Ilustrasi pada Gambar 9.8). Perhatikan, walau disebut _validation_
_data_, group ini digunakan sebagai _testing data_ pada saat proses latihan.
Perlu diperhatikan, distribusi tiap-tiap kelas pada subset data haruslah sama
( _stratified sampling_ ).
Prosedur ini disebut sebagaiK- _fold-cross-validation_. Untuk K=N;
N=jumlah data, disebut sebagai leave-one-out-cross- _validation_. Den-
132 9 Seleksi Fitur dan Metode Evaluasi
gan teknik _cross validation_, kita memiliki sejumlahK model pembelajaran
mesin danKbuah nilai kinerja. Kita dapat mengukur stabilitas model dengan
menghitung varians kinerja dariK model. Nilai rata-rata kinerja yang
diberikan adalah sebuah estimasi terhadap kinerja model pada _testing data_
(yang sesungguhnya tidak ada), diberikan pada persamaan 9.11. Kita ingin
_model_ yang stabil, karena nilai varians yang kecil berarti eksperimen dapat
diulangi, dan kita mendapatkan kinerja yang sama saat eksperimen diulang.
Varians yang terlalu besar dapat berarti kita mendapatkan suatu nilai kinerja
secara _random chance_ (untung-untungan belaka).
```
Performa =
```
#### 1
#### K
#### ∑K
```
i=1
```
```
KinerjaModeli (9.11)
```
|
### 9.4 Evaluasi Kinerja Model
Buku ini telah menjelaskan bahwa model pembelajaran mesin mengoptimisasi
_utility function_ pada saat proses latihan ( _training_ ). Pada umumnya,utility
_function_ berbentuk _cross entropy_ atau _error function_ untuk arsitekturlinear
_model_ dan _neural network_. Untuk arsitektur lain, seperti _support vector_
machine, kita mencari _support vectors_ yang memberikan _margin_ (decision
boundary) terbaik untuk memisahkan dua kelas. Model _decision tree_ dibangun
berdasarkan _information gain_ tiap atribut data. Sementara, modelHidden
Markov Modelmengoptimalkan _forward_ dan _backward probability_. Kegiatan
evaluasi model tidak berhenti saat _training_ telah mencapai nilai _utility function_ yang
optimal, tetapi kita juga mengevaluasi kinerja model pada _validation_
_data_ (baik mengukur _utility function_ dan _performance measure_ ). Terakhir,
kita juga mengevaluasi prediksi model dengan mengukurperformance
measurepada _test data_. Subbab ini akan menjabarkan beberapa contohperformance
measureuntuk mengevaluasi hasil prediksi model pada kasus _supervised_
_learning_.
```
Kelas A Kelas B Kelas C Kelas D
0.2 0.6 0.1 0.1
```
Tabel 9.1: Contoh _class-assignment probability_ pada _multi-class classification_.
Ingat kembali persoalan _multi-class classification_. Tujuan suatu model
pembelajaran mesin adalah mengoptimalkan class- _assignment_ probability,
yaitu probabilitas masing-masing kelas untuk suatu ( _given_ ) _input_ (Tabel 9.1).
Dengan meminimalkan _cross-entropy_ saat proses latihan, kita harap model
bisa memberikan nilai probabilitas yang tinggi untuk kelas yang tepat, dan
nilai yang rendah untuk kelas lainnya ( _high confidence_ ). Namun, urusan evaluasi
_model_ tidak hanya sampai di titik ini saja. _Class-assignment probability_ berikutnya
dikonversi menjadi keputusan final, yaitu memilihsatukelas
mana yang tepat untuk _input_ yang diberikan. Dengan kata lain, kita harus
mengevaluasi penerjemahan “raw” _class-assignment probability_ menjadi sebuah
prediksi final. Pada kasus Tabel 9.1, _output_ atau prediksi final dari
_model_ bersangkutan adalah “Kelas B”.
```
9.4 Evaluasi Kinerja Model 123
```
Sebagai contoh lain, _support vector classifier_ memberikan skor +1 atau
−1 untuk _input_. Skor tersebut berkorespondensi dengan kelas A atau kelas B.
_Output_ final model pun adalah kelas yang tepat untuk _input_ yang diberikan.
Hal yang serupa terjadi pada _Naive Bayes_, _Linear Model_, _Decision Tree_ dan
_supervised learning model_ lain yang dijelaskan pada buku ini ( _term_ asuk _neural_
_network_ ). Walaupun model- _model_ tersebut mengoptimasi _utility function_
atau dikonstruksi dengan cara yang berbeda, prediksi final _multi-class_ _classification_
adalah kelas yang sesuai untuk _input_. Subbab ini membahas cara
mengevaluasi keputusan prediksi final model.
9.4.1 Akurasi
Akurasi adalah _performance measure_ paling sederhana dan sering digunakan
saat mengevaluasi kinerja model. Akurasi didefinisikan sebagai proporsi prediksi
yang benar dibagi dengan banyaknya sampel. Diberikan _desired output_ (juga
dikenal dengan “ _gold standard_ ”)ydan hasil prediksiˆy, kita menghitung proporsi
banyaknya elemen yang sama antaraydanˆy. Secara matematis, akurasi
diformulasikan pada persamaan 9.4, dimanaNmerepresentasikan banyaknya
sampel.
```
Akurasi =
```
#### 1
#### N
#### ∑N
```
i=1
```
```
verdicti
```
```
verdicti=
```
#### {
```
1 , yi= ˆyi
0 , yi 6 = ˆyi
```
#### (9.4)
Sebagai contoh, suatu model pembelajaran mesin mengklasifikan gambar
buah menjadi “ _apel_ ” dan “jeruk” ( _binary classification_ ). _Desired output_ dan
prediksi model diberikan pada Tabel 9.2. Pada tabel ini, ada lima prediksi
yang sama dengan _desired output_, yaitu pada sampel dengan ID=[1, 2 , 4 , 8 ,9].
Dengan demikian, akurasi model adalah 105 = 0.5.
Perhitungan akurasi sama halnya untuk _multi-class classification_, tetapi
menjadi semakin rumit untuk _multi-label classification_. Ingat, padamultilabel
_classification_, suatu _input_ dapat diklasifikasikan menjadi beberapa kelas.
_Multi-label classification_ dapat dievaluasi dengan dua cara. Pertama,
mengevaluasi kinerja pada masing-masing kelas (seolah-olah kita memiliki
beberapa _binary classifier_ ). Cara kedua adalah mengevaluasi prediksimultilabel
secara sekaligus. Perbedaan kedua metode diilustrasikan pada Gambar
9.3. Saat mengevaluasi secara sekaligus, akurasi dapat dihitung sebagai
proporsi banyaknya _exact-match_ dibagi banyaknya sampel.
9.4.2 F1 Score
Metrik yang tidak kalah pentingnya adalah F1 score. F1 score untuk suatu
kelas F1kdidefinisikan sebagai _harmonic mean_ (persamaan 9.5) antara pre-
124 9 Seleksi Fitur dan Metode Evaluasi
```
InstanceDesired Output Hasil Prediksi
1 Jeruk Jeruk
2 Jeruk Jeruk
3 Jeruk Apel
4 Apel Apel
5 Jeruk Apel
6 Apel Jeruk
7 Jeruk Apel
8 Apel Apel
9 Apel Apel
10 Jeruk Apel
```
```
Tabel 9.2: Contoh hasil prediksi model.
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
...
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
...
```
```
Original
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 1
Berita- 2 0 1 1
Berita- 3 0 0 1
...
```
```
Prediction
```
```
Instance Agama Politik Hiburan
1 1 0
0 0 1
0 1 0
...
```
```
Exact match
Partially correct
Complete incorrect
```
```
Evaluate binary
_classification_ sepa _rate_ ly
```
```
Evaluate multi-label
_classification_ at once
Original Prediction
```
```
Gambar 9.3: Cara mengevaluasi _multi-label classifier_ (Gambar 5.8).
```
sisi (persamaan 9.6) dan recall (persamaan 9.7) kelas tersebut. Perhatikan,
yk (persamaan 9.7) melambangkan desired output untuk kelask dan ˆyk
(persamaan 9.6) adalah prediksi untuk kelask. Perhatikan, presisi dan recall
berbeda dari sisi variabel pembagi. Presisi dibagi oleh banyaknya (‖...‖)
prediksi pada kelask, sementara recall dibagi oleh banyaknya prediksiseharusnya(desired
_output_ ) pada kelask.
```
F1k= 2
```
```
Presisik×Recallk
Presisik+ Recallk
```
#### (9.5)
```
9.4 Evaluasi Kinerja Model 125
```
```
Presisik=
```
```
Jumlah prediksi benar pada kelask
‖ˆyk‖
```
#### (9.6)
```
Recallk=
```
```
Jumlah prediksi benar pada kelask
‖yk‖
```
#### (9.7)
Penjelasan sebelumnya cukup _high-level_, sekarang mari kita masuk ke ilustrasi
nyata pada Tabel 9.2. Untuk memudahkan perhitungan, kita susunconfusion
matrixprediksi terlebih dahulu, seperti diilustrasikan pada Tabel 9.3.
_Confusion matrix_ amatlah berguna untuk analisis data, khususnya saat
menghitung F1 score.
```
Prediksi
_apel_ jeruk ‖yk‖
```
```
Gold _apel_ ^314
jeruk 4 2 6
‖ˆyk‖ 7 3
```
```
Tabel 9.3: _Confusion matrix_ prediksi apel dan jeruk berdasarkan Tabel 9.2.
```
```
Berikut adalah cara membaca _confusion matrix_ pada Tabel 9.3:
```
- Ada 3 sampel yang diprediksi sebagai “ _apel_ ” dengan benar.
- Ada 1 sampel yang seharusnya diprediksi sebagai “ _apel_ ”, tetapi diprediksi
sebagai “jeruk”.
- Ada 4 sampel yang seharusnya diprediksi sebagai “jeruk”, tetapi diprediksi
sebagai “ _apel_ ”.
- Ada 2 sampel yang diprediksi sebagai “jeruk” dengan benar.
Nilai‖ˆyk‖untukk=“ _apel_ ” adalah 7, sementara 3 untukk=“jeruk” (jumlah
nilai pada tiap kolom). Nilai‖yk‖adalah 4 dan 6 untukk=“ _apel_ ” dan
k=“jeruk” (jumlah nilai pada tiap baris). Nilai presisi, recall, dan F1 score
untuk masing-masing kelas diberikan pada Tabel 9.4.
```
Kategori Presisi Recall F1 score
Apel^37 =0. 43 34 =0. 75 200 ..^43 43+0×^0 ..^7575 =0. 55
Jeruk^23 =0. 67 26 =0. 33 200 ..^67 67+0×^0 ..^3333 =0.^44
```
Tabel 9.4: Perhitungan nilai presisi, recall dan F1 score untuk masing-masing
kelas untuk contoh Tabel 9.2.
Untuk mendapatkan nilai F1 secara “umum”, kita merata-ratakan F1 _apel_
dan F1jeruk. Prosedur ini disebut _macro-averaging_, yaitu merata-ratakan
126 9 Seleksi Fitur dan Metode Evaluasi
nilai F1 pada masing-masing kelas. Hasilnya disebut sebagai “macro- _average_ d
F1” atau disingkat “F1-macro”. F1-macro untuk contoh pada Tabel 9.3 adalah
0.49.
Terdapat dua variasi lain, yaitu _weighted-average_ (F1- _weight_ ed) dan
_micro-average_ (F1-micro). Pada F1- _weight_ ed, kita memberikan bobot untuk
masing-masing kelas, berdasarkan banyaknya instance yang seharusnya
diklasifikasikan ke kelas tersebut, i.e., banyaknya _desired output_ untuk
masing-masing kelas. F1- _weight_ ed untuk contoh Tabel 9.4 diberikan pada persamaan
9.8. Variasi ini berbeda dengan F1-macro yang menganggap bobot
masing-masing kelas adalah sama.
```
F1- _weight_ ed =
```
#### 4 × 0 .55 + 6× 0. 44
#### 10
#### = 0. 48 (9.8)
F1-macro dan F1- _weight_ ed memisahkan kinerja untuk masing-masing kelas.
Variasi terakhir, F1-micro, melihat hasil prediksi secara keseluruhan tanpa
pemisahan kinerja untuk masing-masing kelas. Sebagai contoh, nilai presisi
dan recall secara keseluruhan diberikan pada persamaan 9.9 dan 9.10. Pada
kasus ini, banyaknya prediksi sama dengan banyaknya prediksi seharusnya.
Dengan demikian, nilai presisi = recall. F1-micro adalah nilai rata-rata presisi
dan recall secara keseluruhan. Karenanya F1-micro = presisi = recall.
Pada kasus _multi-class classification_, nilai F1-micro sama dengan akurasi.
```
Precision =
```
```
Jumlah prediksi benar
Banyaknya prediksi
```
#### =
#### 5
#### 10
#### (9.9)
```
Recall =
```
```
Jumlah prediksi benar
Banyaknya prediksi seharusnya
```
#### =
#### 5
#### 10
#### (9.10)
Ringkasan variasi F1 score diberikan pada Tabel 9.5. F1-macro memiliki
keunggulan dibanding akurasi (F1-micro) dan F1- _weight_ ed pada kasusim _balanced_
_dataset_. Sebagai contoh, kita memiliki sebuah dataset untuk permasalahan _binary_
_classification_ dimana 90% _input_ ditetapkan sebagai kelas A dan
10% sebagai kelas B. Apabila suatu model pembelajaran mesin memprediksi
seluruh data ke kelas A, maka ia akan mendapatkan akurasi 90%. Pada kasus
ini, sesungguhnya model pembelajaran mesin tidak mempelajari distribusi
_data_ dengan benar. Dalam artian, kamu dapat “tertipu” karena nilai akurasi
yang besar, padahal model tersebut sebenarnya tidak memiliki performa yang
baik. F1- _weight_ ed juga akan memberikan nilai yang cukup baik pada kasus ini.
Apabila kita mengukur kinerja menggunakan F1-macro, maka kinerja model
akan terlihat jauh lebih kecil. Cerita ini juga berkaitan dengan _overclaiming_
(subbab 9.6). Akibat penggunaan atau interpretasi metrik yang kurang tepat,
kita mengasumsikan model yang kita buat sudah memiliki kinerja yang cukup
bagus.
```
9.4 Evaluasi Kinerja Model 127
```
```
Metrik Deskripsi
F1-macro Memisahkan kinerja untuk masing-masing kelas, kemudian merataratakan
nilai kinerja.
F1- _weight_ ed Memisahkan kinerja untuk masing-masing kelas, kemudian merataratakan
nilai kinerja dimana setiap kelas memiliki bobot
berdasarkan banyaknya _desired output_ untuk tiap kelas.
F1-micro Melihat hasil prediksi secara keseluruhan tanpa pemisahan kinerja
untuk masing-masing kelas. Nilai F1-micro sama dengan akurasi
pada _multi-class classification_.
```
```
Tabel 9.5: Penjelasan variasi F1 score.
```
9.4.3 Evaluasi Output Berstruktur
Kasus-kasus yang sudah diceritakan pada subbab ini adalah contoh kasus
sederhana baik pada _binary_, _multi-class_ dan _multi-label classification_.
Diberikan sebuah _input_ (e.g., teks, gambar, vektor, suara), kita ingin memprediksi
satu atau beberapa kelas (dari beberapa opsi) yang sesuai untuk
merepresentasikan _input_. Pada kasus yang disebutkan, hasil prediksi suatu
_instance_ adalah independen dari hasil prediksi untuk _instance_ lainnya.
Sekarang, mari kita melanjutkan cerita ke kasus yang lebih kompleks,
yaitu _output_ berstuktur. Pada kasus ini, diberikan sebuah _input_, _output_ model
adalah sebuah data terstruktur, e.g., sekuens kategori, graf, teks.
Sekuens Kategori
Pada _output_ dengan struktur berupa sekuens kategoriy, suatu elemenyi
pada sekuens bisa saja bergantung pada elemen lainnya, misal pada elemen
sebelumnya. Sebagai contoh, pada persoalan Part-of-Speech (POS) _tagging_
(yang sudah dijelaskan pada buku ini), diberikan _inputs_ ekuens katax, kita
ingin memprediksi kelas katayyang bersesuaian (Gambar 9.4). Pada setiap
iterasii, model memprediksi kelas katayiyang cocok bagi _input_ xi. Tujuan
_model_ adalah memprediksi sekuensypaling optimal. Perhatikan, kelas kata
pada posisii(yi) bisa jadi bergantung pada kelas kata di posisii−1 (yi− 1 ),
seperti yang sudah diceritakan pada buku ini. Artinya, suatu elemen _output_ bergantung
pada elemen _output_ lainnya. Walaupun demikian, kita dapat
mengevaluasi tiap elemen _output_ secara independen. Misal, dengan menghitung
akurasi apakah tiap kelas kata pada prediksi ˆyimemang sesuai dengan
_desired output_ yi.
Graf
Evaluasi menjadi cukup kompleks apabila kita memprediksi _output_ dengan
struktur lebih rumit, misalnya sebuah grafG∈(E,V); dimanaE adalah
kumpulan _edge_ danV adalah kumpulan _vertex_. Hal ini cukup lumrah pada
128 9 Seleksi Fitur dan Metode Evaluasi
```
POS tag Noun Verb Noun
Kata Budi Menendang Bola
```
```
Gambar 9.4: Contoh POS _tagging_ (Gambar 8.4).
```
bidang pemrosesan bahasa alami, sebagai contoh pada permasalahanconstituent
parsing, _dependency parsing_, dan _discourse parsing_ (silakan di eksplorasi
lebih lanjut). Gambar 9.5 memberikan contoh _dependency parsing_.
```
Saya suka apel manis
```
```
subjek objek pengubah
```
Gambar 9.5: Ilustrasi _dependency parsing_, dimana kita mencari hubungan
antar-kata (direpresentasikan oleh _edge_ pada graf). Sebagai contoh, “saya”
adalah subjek dari “suka”; “ _apel_ ” adalah objek dari “suka”; “manis” adalah
kata pengubah “ _apel_ ”.
Kita dapat mengevaluasi suatu prediksi struktur dengan cara memfaktorkan
struktur tersebut menjadi unit lebih kecil, kemudian mengevaluasi performa
_model_ pada satuan unit yang lebih kecil. Kinerja model pada satuan
unit diagregat atau digabungkan menjadi satu skor untuk merepresentasikan
keseluruhan performa dalam memprediksi suatu struktur [39]. Pemilihan unit
atau teknik faktorisasi struktur bergantung pada domain permasalahan. Sebagai
contoh, suatu model X yang mampu memprediksi _edges_ pada graph
dengan cukup akurat ternyata tidak dapat memprediksi suatu jalan ( _path_ )
dari _node_ A ke B yang seharusnya ada pada _desired output_. Dengan demikian,
kamu mungkin ingin memfaktorkan graf tersebut menjadi sekumpulan _paths_.
Hal terpenting saat mengevaluasi structured output prediction adalah
mengevaluasi berbagai aspek dan mempertimbangkan berbagai perspektif.
Artinya, memfaktorkan struktur menjadi beberapa (≥1) macam unit, dari
unit yang “kecil” (e.g., _edge_ ) sampai unit yang “besar” (e.g., _subtree_ pada
struktur pohon; _path_ atau subgraph pada graf). Pemilihan unit pada proses
faktorisasi bergantung pada domain permasalahan.
Teks
Evaluasi menjadi semakin kompleks apabila kita tidak dapat mendefinisikan
metrik secara matematis. Misal pada _image captioning task_ : diberikan sebuah
gambar dan suatu model harus menjelaskan apa isi gambar tersebut (ilustrasi
pada Gambar 9.6). Dari sisi “bentuk” _output_, teks adalah sebuah sekuens
kata. Akan tetapi, setiap kata memiliki maknanya tersendiri. Makna kata
```
9.5 Cross Validation 129
```
dapat berubah pada konteksnya, i.e., ketika beberapa kata membentuk sebuah
klausa atau kalimat. Selain itu, teks memiliki struktur “implisit”. Sebagai
contoh, kata-kata pada teks harus membentuk suatu kesatuan makna sebagai
kalimat. Tiap kalimat juga harus sesuai dengan aturan tata bahasa. Hal ini
membuat teks menjadi lebih rumit (dan unik) dibanding sekuens kategori.
```
Image
```
```
Model
"Seseorangsedangbermain
tenis”
```
```
Caption
```
```
Gambar 9.6: Ilustrasi _image captioning task_.
```
Pada kasus _image captioning task_ seperti diatas, bagaimana cara kamu
mengevaluasi apakah model mampu memberikan penjelasan yang merefleksikan
situasi pada gambar? Sebagai contoh, apabila diberikan gambar “seseorang
sedang bermain tenis”, dan model memprediksi “seseorang sedang
bermain basket,” maka model memberikan penjelasan yang salah. Tetapi
apabila kamu melihat dari sisi proporsi banyaknya kata yang sama, terdapat
banyak kata pada _desired output_ yang beririsan dengan prediksi, yaitu
“seseorang sedang bermain.”
Hal serupa juga harus diperhatikan pada persoalan mesin translasi bahasa.
Apakah konten translasi memang benar sama dengan konten aslinya?
Bagaimana dengan gaya penulisan? Pada sistem peringkasan teks, apakah
hasil ringkasan memang benar sesuai dengan teks aslinya, bukan menambah
informasi atau mengada-ada?
Cerita pada subbab 9.4 mengilustrasikan bahwa evaluasi model adalah
perkara yang kompleks. Pemilihan metrik yang salah dapat mengakibatkan
kamu menganggap bahwa model sudah “cukup” baik, padahal model tersebut
memberikan banyak prediksi yang salah. Subbab ini juga sekilas menjelaskan
bahwa bentuk _output_ pada _supervised learning_ bisa saja memiliki struktur
yang rumit.
|
### 9.2 High Dimensional Data
Pada kenyataan, fitur yang kita gunakan untuk membangun model pembelajaran
mesin tidaklah sesederhana yang dicontohkan pada subbab sebelumnya.
Seringkali, kita berhadapan dengan data yang memiliki sangat banyak
fitur ( _high dimensional data_ ). Sebagai contoh, seorang marketing analyst
mungkin saja ingin mengerti pola seseorang berbelanja pada _online shop_.
Untuk mengerti pola tersebut, ia menganalisis seluruh kata kunci pencarian
( _search term_ ) _item_. Misalnya, seseorang yang ingin membeli meja makan
juga mungkin akan membeli kursi (sebagai satu paket). Data pada analisis
semacam ini berdimensi besar. Seberapa besar dimensi yang dapat disebut
_high dimension_ adalah hal yang relatif.
Sayangnya, data dengan dimensi yang sangat besar membawa beberapa
masalah pada pembelajaran mesin. Pertama, model pembelajaran susah untuk
memiliki kinerja yang optimal pada data berdimensi tinggi. Semakin
banyak fitur yang dipakai, semakin kompleks suatu model pembelajaran mesin
harus me _model_ kan permasalahan. Berhubung kita memiliki banyak fitur,
_search space_ untuk mencari konfigurasi parameter optimal sangatlah luas.
Hal ini dapat dianalogikan seperti mencari seseorang pada gedung berlantai
satu vs. gedung berlantai 20. Kedua, hal ini menyebabkan mudah terjadi _overfitting_ karena
ada sangat banyak konfigurasi fitur walaupun kita hanya memiliki
_data_ yang terbatas.^1 Ketiga, data dengan dimensi yang besar susah untuk
diproses secara komputasi ( _computationally expensive_ ), baik dari segi memori
dan waktu. Karenanya hal ini, kita ingin agar fitur-fitur yang kita gunakan
sesedikit mungkin. Dengan kata lain, kita ingin representasi permasalahan
sesederhana mungkin dari sesi memori dan _computational processing_.
|
### 8.5 Algoritma Viterbi
Pada subbab sebelumnya, telah didefinisikan permasalahan POS _tagging_ dan
_Hidden Markov Model_ untuk menyelesaikan permasalahan tersebut. Pada bab
ini, kamu akan mempelajari cara mencari sekuens _syntactical categories_ terbaik
diberikan suatu observasi kalimat menggunakanalgoritma Viterbi. Hal
ini disebut proses _decoding_ pada HMM. Algoritma Viterbi adalah salah satu
algoritma _dynamic programming_ yang prinsip kerjanya mirip denganminimum
edit distance.^6 Ide utama algoritma Viterbi adalah mengingat sekuens
untuk setiap posisi tertentu (setiap iterasi, setiap panjang kalimat). Apabila
kita telah sampai pada kata terakhir, kita lakukan _backtrace_ untuk mendapatkan
sekuens terbaik.
_function_ VITERBI( _observations_ of lenT, _state-graphs_ of lenS)
```
Initialization Step
create a path of probability matrix viterbi[S,T]
foreach statesfrom 1 toSdo
viterbi[s,1]←a 0 ,s×bs(o 1 )
_backpointer_ [s,1]← 0
```
```
Ite _ratio_ n Step
foreach time steptfrom 2 toTdo
foreach statesfrom 1 toSdo
viterbi[s,t]←arg maxj=1,Sviterbi[j,t−1]×as,j×bs(ot)
_backpointer_ [s,t]←index ofjthat gave the max above
```
```
Sequence Identification Step
cT←ithat maximizes viterbi[i,T]
fori=T− 1 to 1 do
ci← _backpointer_ [ci+1,i+ 1]
```
```
Gambar 8.8: Algoritma Viterbi [12, 38].
```
Perhatikan Gambar 8.8 yang menunjukkan _pseudo-code_ untuk algoritma
Viterbi. Variabelcberarti kelas kata,aadalah _transition probability_, danb
adalah _lexical-generation probability_. Pertama-tama, algoritma tersebut membuat
suatu matriks berukuranSxTdenganSadalah banyaknya _states_ (tidak
(^6) https://en.wikipedia.org/wiki/Edit_distance
112 8 Hidden Markov Model
_term_ asuk _start state_ ) danT( _time_ ) adalah panjang sekuens. Pada setiap iterasi,
kita pindah ke observasi kata lainnya. Gambar 8.9 adalah ilustrasi algoritma
Viterbi untuk kalimat _input_ ( _observed sequence_ ) “ _flies like a flower_ ”
dengan _lexical generation probability_ pada Tabel 8.3 dan _transition probabilities_ pada
Tabel 8.2 (bigram) [38]. Panah berwarna merah melambangkan
_backpointer_ yaitu _state_ mana yang memberikan nilai tertinggi untuk ekspansi
ke _state_ berikutnya. Setelah _iteration step_ selesai, kita lakukan _backtrace_ terhadap _state_ terakhir
yang memiliki nilai probabilitas tertinggi dan mendapat
hasil seperti pada Gambar 8.10. Dengan itu, kita mendapatkan sekuens
“ _flies_ /N like/V a/ART flower/N”.
Gambar 8.9: Ilustrasi algoritma Viterbi per iterasi. Panah berwarna merah
melambangkan _backpointer_ – _state_ mana yang memberikan nilai tertinggi untuk
ekspansi.
```
Gambar 8.10: Viterbi _backtrace_.
```
Apabila kamu hanya ingin mengetahui HMM tanpa variabel yang perlu
dilatih/diestimasi, kamu dapat berhenti membaca sampai subbab ini. Apabila
kamu ingin mengetahui bagaimana HMM dapat mengestimasi parameter,
kamu dapat melanjutkan membaca subbab berikutnya.
```
8.6 Proses Training Hidden Markov Model 113
```
|
### Soal Latihan
8.1. Data Numerik
Pada bab ini, diberikan contoh aplikasi Hidden Markov Model (HMM) untuk
POS _tagging_, dimana data kata adalah data nominal. Berikan st _rate_ gi penggunaan
HMM untuk data numerik! Misal, pada _automatic speech recognizer_.
8.2. Ekstensi Algoritma Viterbi
Buatlah ekstensi algoritma Viterbi untuk asumsi trigram!
8.3. Maximum Entropy Markov Model
(a) Jelaskan konsep _maximum entropy_ !
(b) Jelaskan _maximum entropy markov model_ !
8.4. Gibbs Sampling
(a) Jelaskan bagaimana Gibbs sampling digunakan pada HMM!
(b) Jelaskan penggunaan variasi/ekstensi Gibbs sampling pada HMM!
8.5. Latent Dirichlet Allocation
Salah satu materi yang berkaitan erat dengan HMM adalahLatent Dirichlet
Allocation(LDA) yang merupakan anggota keluarga _graphical model_. Jelaskan
apa itu LDA serta bagaimana cara kerja LDA!
|
### 8.1 Probabilistic Reasoning
Pada logika matematika ( _first order logic_ ), ketika kita memiliki premis “bila
hujan, maka ayu terpeleset.” Pada level _first order logic_, apabila “hujan” ter-
(^1) Karena perlu dijelaskan juga cara transformasi sinyal suara menjadi data diskrit.
```
102 8 Hidden Markov Model
```
```
jadi, maka “terpeleset” juga pasti akan terjadi. Tetapi tidak sebaliknya, apabila
kita “terpeleset”, belum tentu “hujan” juga terjadi. Padaprobabilistic
_reasoning_ kita mengkuantifikasi kepastian atau ketidakpastian itu. Apabila
“hujan” terjadi, berapa besar kemungkinan “terpeleset” juga terjadi (dan se-
baliknya).
Perhatikan Gambar 8.1! Gambar ini menerangkan hubungan pengkondisian _events_,
disebut _Bayesian Network_. Panah dari “hujan” ke “terpeleset”
merepresentasikan bahwa “hujan” adalah kondisi yang menyebabkan
“terpeleset” terjadi ( _causality_ ). Pada kerangka _probabilistic reasoning_, kita
berpikir “karena ada yang terpeleset, mungkin ada hujan dan kecelakaan juga
terjadi.” Tetapi, apabila ada cerita lain bahwa jika ada seseorang yang “terpeleset”
dan memang “hujan”; belum tentu “kecelakaan” terjadi.
```
```
Gambar 8.1: Contoh _Bayesian Network_.
```
```
Gambar 8.2: Tipe jaringan kausalitas.
```
```
Berdasarkan hubungan/jaringan kausalitas antara _events_, ada beberapa
kerangka berpikir yang dapat digunakan: _serial_, _diverging_, dan _converging_ [5];
diilustrasikan pada Gambar 8.2. Karakteristik dari masing-masing tipe kausalitas
adalah sebagai berikut [5]:
```
(a) _Serial_. Bila kita mengetahuiAmaka kita bisa mengetahui sesuatu tentang
BdanC. Tetapi apabila kita mengetahuiB, mengetahuiAtidak akan
membantu inferensi kita terhadapC. MengetahuiCakan membuat kita
mengetahui sesuatu tentangAketika kita tidak mengetahuiB. Artinya,
hubungan antaraAdanCdi- _block_ ketikaBdiketahui. Dengan bahasa
```
8.1 Probabilistic Reasoning 103
```
lebih matematis,AdanC bersifatindependen kondisional(conditionally
_independent_ ) ketikaBdiketahui. Perhatikan, disebut _kondisional_
karena independen jika kondisi (mengetahuiB) terpenuhi.
(b) Diverging. Bila kita mengetahuiAmaka kita bisa mengetahui sesuatu
tentangC, dan sebaliknya. Tetapi apabilaBdiketahui, maka hubungan
antaraAdanCmenjadi terputus. Dengan bahasa lebih matematis,Adan
Cindependen kondisional ketikaBdiketahui.
(c) _Converging_. Tanpa mengetahuiB, kita tidak bisa mencari tahu hubungan
antaraAdanC. Dengan bahasa lebih matematis,AdanCdependen
_kondisional_ ketikaBdiketahui.
Dua buah _events_ XdanYdisebut _d-separated_ apabila terdapat sebuah
_intermediate variable_ Zdiantara mereka dan memenuhi kondisi:
1. Koneksi bersifat _serial_ atau _diverging_, danZdiketahui.
2. Koneksi bersifat _converging_ danZtidak diketahui.
3. Bila tidak memenuhi kondisi yang disebutkan, artinya dua buah variabel
tersebut tidak _d-separated_, disebut sebagai _d-connected_.
Konsep ini penting dipahami untuk mengerti ide dasar _markov assumption_
yang dibahas pada subbab berikutnya.
```
Gambar 8.3: Contoh inferensi.
```
```
Perhatikan Gambar 8.3! Dengan konsep yang sudah dipahami, mari kita
coba lakukan inferensi pada jaringan tersebut. _Joint distribution_ untuk seluruh _event_ diberikan
pada persamaan 8.1.
```
#### P(A,B,C,D,E) =P(D|B)P(E|B)P(B|A,C)P(A)P(C) (8.1)
```
Sekarang, mari kita hanya lihat subgraf{A,B,E}dengan koneksi tipe _serial_.
BilaAdiketahui, maka kita dapat melakukan inferensi terhadapC, seperti
pada persamaan 8.2.
```
```
P(E|A) =P(E|B)P(B|A)P(A) +P(E|¬B)P(¬B|A)P(A) (8.2)
```
104 8 Hidden Markov Model
Tetapi, apabilaAdan Bdiketahui, maka inferensi terhadapEdilakukan
seperti pada persamaan 8.3.
```
P(E|B,A) =P(E|B)P(B) (8.3)
```
Operasi serupa dapat diaplikasikan pada koneksi tipe _converging_ dan _diverging_.
Perhatikan subgraf{A,B,C}dengan tipe koneksi _converging_ pada Gambar
8.3. ApabilaBtidak diketahui, berartiAdanCterpisah (independen).
ApabilaBdanAdiketahui, maka hubunganAdanCdapat dihitung sebagai
persamaan 8.4.
```
P(C|B,A) =P(C|B)P(B|A)P(A) (8.4)
```
Untuk koneksi tipe _diverging_, silahkan coba bagaimana mencari proses inferensinya!
(pekerjaan rumah).
|
### 8.6 Proses Training Hidden Markov Model
_Hidden Markov Model_ (HMM) adalah salah satu varian _supervised learning_,^7
diberikan sekuens _input_ dan _output_ yang bersesuaian sebagai _training data_.
Pada kasus POS _tagging_, yaitu _input_ -nya adalah sekuens kata dan _output_ -nya
adalah sekuens kelas kata (masing-masing kata/ _token_ berkorespondensi dengan
kelas kata). Saat melatih HMM, kita ingin mengestimasi parameterAdan
byaitu _transition probabilities_ dan _emission probabilities_ /lexical- _generation_
probabilities(ingat kembali definisi HMM secara formal pada subbab 8.4).
Kita melatih HMM dengan menggunakanAlgoritma Forward-Backward
(Baum-Welch Algorithm).
Cara paling sederhana untuk menghitung emission probabilities atau
_transition probabilities_ adalah dengan menghitung kemunculan pada sampel
( _training data_ ). Sebagai contoh, _emission probability_ suatu kata untuk setiap
kelas kata diberikan pada persamaan 8.14, dimanaN melambangkan
banyaknya kemunculan katawiterlepas dari kelasnya.
```
P(wi|ci) =
```
```
count(wi,ci)
∑N
j=1count(wi,cj)
```
#### (8.14)
Akan tetapi, perhitungan tersebut mengasumsikan _context-independent_, artinya
tidak mempedulikan keseluruhan sekuens. Estimasi lebih baik adalah dengan
menghitung seberapa mungkin suatu kategoricipada posisi tertentu (indeks
kata/ _token_ pada kalimat) pada semua kemungkinan sekuens, diberikan inputw
1 ,w 2 ,...,wT. Kami ambil contoh, kata _flies_ sebagai _noun_ pada kalimat
“ _The flies like flowers_ ”, dihitung sebagai penjumlahan seluruh sekuens yang
berakhir dengan _flies_ sebagai _noun_. ProbabilitasP( _flies_ /N|The flies) =
P( _flies_ /N&The flies)
P(The flies).
Agar lebih _precise_, secara formal, kita definisikan terlebih dahulu _forward_
probabilitysebagai 8.15, dimanaαi(t) adalah probabilitas untuk menghasilkan
kataw 1 ,w 2 ,...,wtdenganwtdihasilkan ( _emitted_ ) olehci.
```
αi(t) =P(wt/ci|w 1 ,w 2 ,...,wt) (8.15)
```
_Pseudo-code_ perhitungan kemunculan kelascisebagai kategori pada posisi
tertentu diberikan oleh Gambar 8.11, denganciadalah kelas kata ke-idanwi
adalah kata ke-i,aadalah _transition probability_,badalah _emission probability_,
danSmelambangkan banyaknya _states_.
Sekarang, kita definisikan juga _backward probability_ βi(t), yaitu probabilitas
untuk menghasilkan sekuenswt,...,wTdimulai dari _state_ wt/ci(ci
menghasilkanwt). Hal ini serupa dengan _forward probability_, tetapi _backward_
probabilitydihitung dari posisi ke-tsampai ujung akhir (tkeT). Anda dapat
melihat _pseudo-code_ pada Gambar 8.12, denganaadalah _transition probability_
danbadalah _emission probability_.
(^7) Walaupun ia termasuk _generative model_.tetapi komponen utama yang di _model_ kan
adalahp(y|x)
114 8 Hidden Markov Model
Initialization Step
fori= 1toSdo
αi(t)←bi(o 1 )×a 0 ,i
Comparing the Forward Probabilities
fort= 2toTdo
fori= 1toSdo
αi(t)←
```
∑S
j=1(aji×αj(t−1))×bi(ot)
```
```
Gambar 8.11: Algoritma _forward_ [38].
```
Initialization Step
fori= 1toSdo
βi(T)←P(ci) # as _sign_ ed using a particular classci
Comparing the Backward Probabilities
fort=T− 1 totdo
fori= 1toSdo
βi(t)←
```
∑S
j=1(aji×βi(t+ 1))×bj(oj+1)
```
```
Gambar 8.12: Algoritma _backward_ [38].
```
Gabungan _forward_ dan _backward probability_ dapat digunakan untuk mengestimasiγj(t)
yaitu probabilitas berada pada _state_ cjpada waktu ke-tdengan
persamaan 8.16.
```
γj(t) =
αi(t)×βi(t)
∑S
j=1αj(t)×βj(t)
```
#### (8.16)
Kita mengestimasi probabilitas keberadaan pada _state_ tertentu, berdasarkan
pengaruh probabilitas keseluruhan sekuens.
Dengan menggunakan _forward probability_ dan _backward probability_ sekaligus,
kita definisikanξt(i,j) yaitu probabilitas berada di _state-i_ pada waktu
ketdan _state_ -jpada waktu ke-(t+ 1) dengan persamaan 8.17.
```
ξt(i,j) =
αi(t)×aij×bj(ot+1)×βj(t+ 1))
αS(T)
```
#### (8.17)
Denganaijadalah _transition probability_ danbj(ot+1) adalah _emission probability_ (ingat
kembali definisi formal HMM pada subbab 8.4). Pada setiap iterasi,
kita ingin memperbaharui kembali parameter HMM yaituAdanb. Kita
hitung kembali _transition probability_ (nilai yang lama di- _update_ ), diberikan
oleh persamaan 8.18.
```
8.6 Proses Training Hidden Markov Model 115
```
```
aij′=
```
#### ∑T− 1
```
∑ t=1 ξt(i,j)
T− 1
t=1
```
#### ∑S
```
j=1ξt(i,j)
```
#### (8.18)
Kita juga menghitung kembali _emission probability_ (nilai yang lama di _update_ ),
diberikan oleh persamaan 8.19.
```
bj(ok)′=
```
#### ∑T
```
t=1,ok=wkγj(t)
∑T
t=1γj(t)
```
#### (8.19)
#### ∑T
```
t=1,ok=wkberarti jumlah observasiwkpada waktut.
```
Initialize A and b
Ite _rate_ until convergence
E-step
γj(t) =∑Sαi(t)×βi(t)
j=1αj(t)×βj(t)
```
ξt(i,j) =
αi(t)×aij×bj(ot+1)×βj(t+1))
αS(T)
```
```
M-step
_update_ aij′=
```
```
∑T− 1
∑T− 1 t=1ξt(i,j)
t=1
```
```
∑S
j=1ξt(i,j)
```
```
_update_ bj(ok)′=
```
```
∑T
t=1∑,ok=wkγj(t)
Tt=1γj(t)
```
```
Gambar 8.13: Algoritma _forward-backward_ (EM) [12].
```
Keseluruhan proses ini adalah cara melatih HMM dengan menggunakan
kerangka berpikir _Expectation Maximization_ : terdiri dariE-stepdanMstep[12].
Pada E-step, kita mengestimasi probabilitas berada di suatu _state_
cjmenggunakanγj(t) dan mengestimasi transisiξt(i,j) berdasarkan parameterAdanbyang
sudah diberikan pada tahap iterasi _training_ ( _epoch_ ) sebelumnya.
Pada M-step, kita menggunakanγdanξuntuk mengestimasi kembali
parameterAdanb. Hal ini dijelaskan secara formal pada Gambar 8.13.
Walaupun HMM menggunakan _independence assumption_, tetapi kita dapat
mengikutsertakanpengaruh probabilitas keseluruhan sekuens untuk
perhitungan probabilitas keberadaan kita pada suatu _state_ ipada
saat ( _time_ t) tertentu. Metode ini dapat dianggap sebagai suatu cara optimalisasi
menggunakan _smoothing_ ^8 terhadap nilai parameter (Adanb). Kita
mencapai titik _local optimal_ apabila tidak ada perubahan parameter.
(^8) https://en.wikipedia.org/wiki/Smoothing
116 8 Hidden Markov Model
Kami ingin mengakui bahwa penjelasan pada subbab 8.6 mungkin kurang
baik (kurang memuaskan). Kami harap kamu mencari referensi lain yang lebih
baik untuk subbab ini.
|
### 8.2 Generative Model
Pada _supervised learning_ kamu sudah mengetahui bahwa kita me _model_ kan
p(y|x), me _model_ kan _target_ y(label) ketika diberikan _input_ x,^2 yaitu mencari
tahu _decision boundary_ antara keputusan.xdanydapat berupa vektor, skalar,
gambar, dan lain sebagainya. Sementara pada _unsupervised learning_, kita ingin
mengaproksimasi distribusi asli dari sebuah _inputs_ ebagaip(x).
Berbeda dengan keduanya, _generative model_ me _model_ kanp(x,y). Persamaan
itu dapat difaktorkan sebagaip(x,y) =p(y|x)p(x). Pada umumnya,
kita lebih tertarik dengan nilaiyyang menyebabkanp(x,y) bernilai maksimum,
berhubungxakan selalu tetap–karenaxadalah _fixed input_,yterbaiklah
yang ingin kita temukan. Berbeda dengan _supervised learning_, _generative_
_model_ dapat difaktorkan menjadip(y|x) danp(x). Karena berbentukjoint
probability, _generative model_ me _model_ kan peluang kemunculan bersamaan.
Kita ingin mengetahui seberapa mungkin suatu dataxdihasilkan, diberikan
y. Artinya seberapa mungkin _input_ diobservasi untuk suatu _output_. Salah satu
contoh _generative model_ adalah _Hidden Markov Model_ (HMM). HMM me _model_ kan
observasi menggunakan proses _Markovian_ dengan _state_ yang tidak
diketahui secara jelas ( _hidden_ ). Kamu akan mengerti kalimat sebelumnya setelah
membaca penjelasan buku ini seluruhnya.
Ide utama HMM adalah menyelesaikan persoalan _sequence tagging_.
Diberi-kan _input x_ berupa sekuens (sekuens sinyal, sekuens kata, sekuens
gambar, dsb). Kita ingin me _model_ kan sekuens _output_ terbaikyuntuk input
tersebut.^3 Outputke-ibergantung pada _input_ dari awal sampai ke-idan _output_ dari
awal sampai sebelumnyap(yi|y 1 ,...,yi− 1 ,x 1 ,...,xi). Berdasarkan
pemaparan subbab 8.1, apabila suatu _event_ dikondisikan variabel lain dengan
(^2) Parameterwdihilangkan untuk menyederhanakan penjelasan.
(^3) xidanyidapat berupa vektor
```
8.3 Part-of-speech Tagging 105
```
tipe koneksi _serial_, maka kita dapat mengabaikan banyak variabel historis.
Hal ini dituangkan dalam persamaan 8.5,
```
p(yi|y 1 ,...,yi− 1 ,x 1 ,...,xi) =p(yi|yi− 1 ,xi) (8.5)
```
Persamaan ini disebut _first-order markov assumption_, yaitu suatu _event_
yang seharusnya dikondisikan oleh suatu histori hanya bergantung pada
_events_ ebelumnya. Terdapat pula _second_, _third_, dst _markov assumption_ yaitu
bergantung pada dua, tiga, dst _events_ sebelumnya. Walaupun hanya berupa
penyederhanaan, asumsi ini memberi kita banyak keuntungan dari sisi kom-
putasi.
|
### 8.4 Hidden Markov Model Tagger
Pada subbab sebelumnya, POS _tagging_ telah didefinisikan secara matematis.
Kita sudah mengetahui permasalahan yang ingin kita selesaikan. Subbab ini
adalah formalisasi _hidden markov model tagger_.
Ingat kembali persamaan 8.12 untuk POS tagging.P(wi|ci) disebut _likelihood_ danP(ci|ci−
1 ) disebut _prior_, _multiplication of probabilities_ (
#### ∏
) melambangkanmarkov
chain. _Markov chain_ adalah kasus spesial _weighted automaton_ ^5
yang mana sekuens _input_ menentukan _states_ yang akan dilewati
oleh automaton. Sederhananya, automaton mencapai _goal state_ setelah mengunjungi
berbagai _states_. Total bobot _outgoing edges_ untuk masing-masing
_state_ pada automaton haruslah bernilai satu apabila dijumlahkan. Kasus spesial
yang dimaksud adalah _emission_ (dijelaskan kemudian).
Sebagai contoh, perhatikan Tabel 8.2.ARTadalah _article_,Nadalah _noun_,
V adalah _verb_ danP adalah _preposition_. Mereka adalah contoh kelas kata
yang disederhanakan demi membuat contoh yang mudah. Tabel 8.2 yang
merepresentasikan probabilitas transisi kelas kata, ketika dikonversi menjadi
_weighted automaton_, akan menjadi Gambar 8.5.
```
NULL
```
```
ART V
```
```
N P
```
```
START
```
```
0.71
```
```
0.29
```
```
1
```
```
0.65
```
```
0.43
0.35
```
```
0.26
```
```
0.44
0.13
```
```
0.74
```
```
Gambar 8.5:Weighted automaton[38].
```
(^5) Kami berasumsi kamu sudah mempelajari automata sebelum membaca buku ini.
```
8.4 Hidden Markov Model Tagger 109
```
```
Bigram Estimate
P(ART|null) 0.71
P(N|null) 0.29
P(N|ART) 1
P(V|N) 0.43
P(N|N) 0.13
P(P|N) 0.44
P(N|V) 0.35
P(ART|V) 0.65
P(ART|P) 0.74
P(N|P) 0.26
```
```
Tabel 8.2: Probabilitas bigram [38].
```
Tabel 8.2 dan Gambar 8.5 telah merepresentasikan probabilitas _prior_,
sekarang kita ingin model yang kita punya juga mencakuplexical emission
probabilities, yaitu _likelihood_ pada persamaan 8.12.
```
P(the|ART) 0.54 P(a|ART) 0.360
P( _flies_ |N) 0.025 P(a|N) 0.001
P( _flies_ |V) 0.076 P(flower|N) 0.063
P(like|V) 0.1 P(flower|V) 0.05
P(like|P) 0.068 P(birds|N) 0.076
P(like|N) 0.012
```
Tabel 8.3:Lexical emission probabilities[38]. Tabel ini hanya memuat informasi
yang dibutuhkan untuk ilustrasi cerita (penyederhanaan).
Seumpama kita mempunyai _lexical emission probabilities_ seperti pada
Tabel 8.3. Setiap _state_ pada automaton, dapat menghasilkan/meng- _output_ kan
suatu kata ( _word_ ) dengan probabilitas pada Tabel 8.3. Kita kembangkan
lagi Gambar 8.5 dengan tambahan informasi _lexical emission probabilities_
menjadi Gambar 8.6. Automaton ini disebut _hidden markov model_ (HMM).
Kata _hidden_ berarti, untuk setiap kata pada sekuens, kita tidak mengetahui
kata tersebut dihasilkan oleh _state_ mana secara model (baru diketahui saat
_running_ ). Misalkan, kata _flies_ dapat dihasilkan oleh _state_ N( _noun_ ) atauV
( _verb_ ) [38].
Diberikan kalimat “ _flies like a flower_ ”, untuk menghitung sekuens kelas
kata untuk kalimat tersebut, kita menyelusuri automaton Gambar 8.6. Hasil
penelusuran memberikan kita kombinasi sekuens yang mungkin seperti pada
Gambar 8.7. Pekerjaan berikutnya adalah, dari seluruh kombinasi sekuens
yang mungkin, yaitu
#### ∏T
```
i=1P(wi|ci)P(ci|ci−^1 ). Bagaimana cara kita menen-
```
110 8 Hidden Markov Model
```
NULL
```
```
ART V
```
```
N P
```
```
START
```
```
0.71
```
```
0.29
```
```
1
```
```
0.65
```
```
0.43
0.35
```
```
0.26
```
```
0.44
0.13
```
```
0.74
```
```
P(the|ART) = 0.54
P(a|ART) = 0.360
```
```
P( _flies_ |V) = 0.76
P(flower|V)= 0.05
P(like|V) = 0.1
```
```
P(P( _flies_ |Na|N) ) = 0.25= 0.001 P(like|P) = 0.068
P(flower|N)= 0.063
P(like|N) = 0.012
P(birds|N) = 0.076
```
```
Gambar 8.6: _Hidden Markov Model_.
```
```
Gambar 8.7: Sekuens yang mungkin ( _brute force_ ).
```
tukan sekuens terbaik (paling optimal), yaitu sekuens dengan probabilitas
tertinggi, diberikan pada subbab berikutnya.
Secara formal, _hidden markov model tagger_ didefinisikan oleh beberapa
komponen [12]:
```
1.Q={q 1 ,q 2 ,...,qS}yaitu himpunan _states_ ;Smenunjukkan banyaknya
_states_.
2.A=a 0 , 0 ,a 1 , 1 ,a 2 , 2 ,...,aS,Syaitu _transition probability_ matrixdari
suatu _state_ imenuju _state_ j; dimana
```
#### ∑S
```
j=0ai,j= 1. Indeks 0 merepresentasikanstart
_state_ ( _null state_ ).Smelambangkan banyaknya _states_.
3.o=o 1 ,o 2 ,...,oTyaitu sekuensobservasi(kata/ _input_ );Tadalah panjang
_input_.
4.b=bi(ow) yaitu sekuens dari _observation likelihood_, atau disebut dengan _emission_
probabilities, merepresentasikan sebuah observasi kataow
dihasilkan oleh suatu _state-i_.
```
```
8.5 Algoritma Viterbi 111
```
```
5.q 0 ,qFyaitu kumpulan _states_ pesial yang terdiri dari _start state_ danfinal
_state_ (s).
```
|
### 8.3 Part-of-speech Tagging
Pada bidang pemrosesan bahasa alami ( _natural language processing_ ), peneliti
tertarik untuk mengetahui kelas kata untuk masing-masing kata di tiap kalimat.
Misalkan kamu diberikan sebuah kalimat “ _Budi menendang bola_ ”. Setelah
proses POS _tagging_, kamu akan mendapat “Budi/Noun menendang/Verb
bola/Noun” (Gambar 8.4). Hal ini sangat berguna pada bidang pemrosesan
bahasa alami, misalkan untuk memilih _noun_ pada kalimat. Kelas kata disebut
sebagai _syntactic categories_. Pada bahasa Inggris, kita mempunyai kelas kata
yang dikenal dengan _Penn Treebank POS Tags_,^4 diberikan pada Tabel 8.1.
```
POS tag Noun Verb Noun
Kata Budi Menendang Bola
```
```
Gambar 8.4: Contoh POS _tagging_.
```
POS _tagging_ adalah salah satu bentuk pekerjaan _sequential classification_.
Diberikan sebuah sekuens kata (membentuk satu kalimat), kita ingin
menentukan kelas setiap kata/ _token_ pada kalimat tersebut. Kita ingin
memilih sekuens kelas kata _syntactic categories_ yang paling cocok untuk katakata/ _tokens_
pada kalimat yang diberikan. Secara formal, diberikan sekuens
kata-kataw 1 ,w 2 ,...,wT, kita ingin mencari sekuens kelas katac 1 ,c 2 ,...,cT
sedemikian sehingga kita memaksimalkan nilai probabilitas 8.6 [12, 38].
```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
```
P(c 1 ,c 2 ,...,cN|w 1 ,w 2 ,...,wT) (8.6)
```
DimanaCadalah daftar kelas kata. Akan tetapi, menghitung persamaan 8.6
sangatlah sulit karena dibutuhkan data yang sangat banyak (kombinasi sekuens
(^4) https://www.ling.upenn.edu/courses/Fall_ _2003/ling001/penn_ _treebank_
pos.html
106 8 Hidden Markov Model
```
No. Tag Description
```
1. CC Coordinating conjunction
2. CD Cardinal number
3. DT De _term_ iner
4. EX Existential there
5. FW Foreign word
6. IN Preposition or subordinating conjunction
7. JJ Adjective
8. JJR Adjective, comparative
9. JJS Adjective, superlative
10. LS List item marker
11. MD Modal
12. NN Noun, singular or mass
13. NNS Noun plural
14. NNP Proper noun singular
15. NNPS Proper noun plural
16. PDT Pre _determiner_
17. POS Possessive ending
18. PRP Personal pro _noun_
19. PRP$ Possessive pro _noun_
20. RB Ad _verb_
21. RBR Ad _verb_, comparative
22. RBS Ad _verb_, superlative
23. RP P _article_
24. SYM Symbol
25. TO to
26. UH Interjection
27. VB Verb base form
28. VBD Verb past tense
29. VBG Verb gerund or present participle
30. VBN Verb past participle
31. VBP Verb non-3rd person singular present
32. VBZ Verb 3rd person singular present
33. WDT Wh- _determiner_
34. WP Wh-pro _noun_
35. WP$ Possessive wh-pro _noun_
36. WRB Wh-ad _verb_
```
Tabel 8.1: Penn Treebank POS Tag.
```
kata sangat sulit untuk didaftar/sangat banyak). Teori Bayes digunakan untuk
melakukan aproksimasi permasalahan ini. Ingat kembali teori Bayes seperti
pada persamaan 8.7.
```
P(x|y) =
P(y|x)P(x)
P(y)
```
#### (8.7)
```
8.3 Part-of-speech Tagging 107
```
Dengan menggunakan teori Bayes, kita dapat mentransformasi persamaan 8.6
menjadi persamaan 8.8.
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)P(c 1 ,c 2 ,...,cT)
P(w 1 ,w 2 ,...,wT)
(8.8)
```
Untuk suatu sekuens input,P(w 1 ,w 2 ,...,wT) ( _language model_ ) akan selalu
sama sehingga dapat diabaikan (karena operasi yang dilakukan adalah
mengubah-ubah atau mencaric). Oleh karena itu, persamaan 8.8 dapat
disederhanakan menjadi 8.9.
```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)P(c 1 ,c 2 ,...,cT)
```
(8.9)
Pada persamaan 8.9, kombinasi sekuens kelas kata jauh lebih sedikit dibanding
kombinasi sekuens kata (karena kelas kata jumlahnya lebih terbatas). Ingat
kembaliP(c 1 ,c 2 ,...,cT) disebut _prior_,P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)
disebut _likelihood_ (bab 2).
Persamaan 8.9 masih dapat disederhanakan kembali menggunakanmarkov
assumption, yaitu dengan membuat asumsi saling lepas pada sekuens (disebutindependence
assumption). Terdapat dua asumsi, pertama, kategori
suatu kata hanya bergantung pada dirinya sendiri tanpa memperhitungkan
kelas kata disekitarnya, seperti pada persamaan 8.10. Asumsi kedua adalah
suatu kemunculan kategori kata hanya bergantung pada kelas kata sebelumnya,
seperti pada persamaan 8.11.
```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT) =
```
#### ∏T
```
i=1
```
```
P(wi|ci) (8.10)
```
```
P(c 1 ,c 2 ,...,cT) =
```
#### ∏T
```
i=1
```
```
P(ci|ci− 1 ) (8.11)
```
Dengan demikian, persamaan 8.9 disederhanakan kembali menjadi persamaan
8.12 yang disebut _bigram assumption_ atau _first-order markov chain_,
dimanaTmelambangkan panjangnya sekuens.
```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
#### ∏T
```
i=1
```
```
P(wi|ci)P(ci|ci− 1 ) (8.12)
```
Kita dapat membuat ekstensi persamaan 8.12 dengan _trigram assumption_, _quadgram_
assumption, dan seterusnya.P(ci|ci− 1 ,ci− 2 ) untuk _trigram_,P(ci|ci−
1 ,ci− 2 ,ci− 3 ) untuk _quadgram_. Walau menghitung probabilitas
seluruh sekuens adalah hal yang susah, hal tersebut dapat di _model_ kan dengan
108 8 Hidden Markov Model
lebih baik menggunakan _recurrent neural network_ (subbab 13.2). Anda dapat
membaca subbab tersebut kemudian, ada baiknya kita mengerti pendekatan
yang lebih sederhana terlebih dahulu.
Sebagai contoh, untuk kalimat “ _budi menendang bola_ ”, peluang kalimat
tersebut memiliki sekuens kelas kata “ _noun_, _verb_, _noun_ ” adalah
```
P( _noun_, _verb_, _noun_ ) =P(budi| _noun_ )P( _noun_ |null)P(menendang| _verb_ )
P( _verb_ | _noun_ )P(bola| _noun_ )P( _noun_ | _verb_ )
(8.13)
```
|
### 6.3 Isu pada ID3
Pada algoritma _decision tree_ secara umum, terdapat beberapa isu diantara
lain [7, 36]:
1. Mudah overfitting
2. Masalah menangani atribut kontinu
3. _Information gain_ memiliki bias terhadap atribut yang memiliki banyak
nilai ( _highly-branching attributes_ )
4. Data dengan _missing value_. Beberapa sel pada tabel dataset tidak terisi.
5. Data dengan _unseen value_. Misal nilai atribut yang tidak pernah dilihat
pada _training data_, muncul saat _testing_.
|
### 6.1 Inductive Learning
Salah satu bentuk “kecerdasan” sederhana kemungkinan adalah dalam bentuk
aturan ( _rule_ ) yang merepresentasikan pengetahuan. Misalkan, untuk
menentukan apakah suatu pasien terserang penyakit tertentu, dokter mencari
tahu gejala-gejala yang ada. Berdasarkan gejala-gejala yang ada, dokter
memutuskan bahwa pasien memiliki suatu penyakit. Pada zaman dahulu,
peneliti mentranskripsi aturan-aturan ( _if then_ ) eksplisit (berdasarkan pengetahuan
ahli) untuk membuat agen cerdas ( _expert system_ ). Aturan sangat
berguna, tetapi proses transkripsi pengetahuan sang ahli menjadi aturan formal
(matematis) adalah hal yang sulit. Terlebih lagi, aturan-aturan yang sudah
dibangun cenderung tidak dapat diubah dengan mudah.
Pada era _big data_ seperti sekarang, kita dapat mengotomatisasi hal tersebut
dengan membuat aturan-aturan secara otomatis berdasarkan contoh data
yang ada ( _machine learning_ ). Pendekatan ini disebut _inductive learning_, yaitu
mengembangkan aturan klasifikasi yang dapat menentukan kelas suatu _instance_ berdasarkan
nilai atributnya ( _feature vector_ ). Cara paling sederhana
diberikan pada subbab 3.3 yaitu mendaftarkan seluruh kemungkinan aturan
yang ada, kemudian menghapus yang kurang cocok. Algoritma lebih baik
adalah dengan membangun pohon keputusan ( _decision tree_ ).
84 6 Pohon Keputusan
|
### Soal Latihan
6.1. Isu
Pada subbab 6.3, telah disebutkan isu-isu yang ada pada ID3, sebutkan dan
jelaskan bagaimana cara menangani masing-masing isu tersebut!
6.2. Gain Ratio
Selain _information gain_, kita dapat menggunakan cara lain untuk memilih
atribut bernama _gain ratio_. Jelaskan perbedaan keduanya! Yang mana lebih
baik?
6.3. C4.5
ID3 disempurnakan kembali oleh pembuat aslinya menjadi C4.5. Jelaskanlah
perbedaan ID3 dan C4.5, beserta alasan st _rate_ gi penyempurnaan!
6.4. Pruning
Jelaskan apa itu _pruning_ dan bagaimana cara melakukan _pruning_ untukdecision
tree!
6.5. Association Rule
Terdapat beberapa algoritma _association rule_ yang membentuk aturan-aturan
seperti _decision tree_.
(a) Jelaskanlah algoritma PRISM dan A _prior_ i!
(b) Jelaskan perbedaan _association rule_ dan _inductive learning_ !
6.6. Final Decision Tree
Lanjutkanlah proses konstruksi ID3 untuk Tabel 6.1 hingga membentukdecision
treeakhir seperti pada Gambar 6.1!
6.7. Variant
Jelaskanlah _Random Forest_, _Bagging_ dan _Boosting_ pada _Decision Tree_ !
|
### 6.2 ID3
_Decision tree_ adalah varian dari _inductive learning_. ID3 adalah salah satu
algoritma varian _decision tree_ [34]. _Decision tree_ dibangun berdasarkan asumsi
bila atribut yang ada memberikan informasi yang cukup memadai maka kita
mampu membangun _decision tree_ yang mampu mengklasifikasikan seluruh
_instance_ di _training data_ [34]. Akan tetapi, kita tentunya ingin melakukan
generalisasi, yaitu _decision tree_ yang juga mampu mengklasifikasikan objek
dengan benar untuk _input_ yang tidak ada di _training data_ ( _unseen instances_ ).
Oleh karena itu, kita harus mampu mencari hubungan antara kelas dan nilai
atribut.
```
Gambar 6.1:Final decision tree
```
```
id outlook temperature humidity windy play ( _class_ )
1 sunny hot high false no
2 sunny hot high true no
3 overcast hot high false yes
4 rainy mild high false yes
5 rainy cool normal false yes
6 rainy cool normal true no
7 overcast cool normal true yes
8 sunny mild high false no
9 sunny cool normal false yes
10 rainy mild normal false yes
11 sunny mild normal true yes
12 overcast mild high true yes
13 overcast hot normal false yes
14 rainy mild high true no
```
```
Tabel 6.1: Contoh dataset _play tennis_ (UCI machine learning repository).
```
```
6.2 ID3 85
```
St _rate_ gi pembangunan ID3 adalah berdasarkan _top-down_ rekursif. Pertama,
kita pilih atribut untuk _root_ pohon, lalu membuat cabang untuk setiap
nilai atribut yang mungkin. Untuk masing-masing cabang, kita buat _subtree_.
Kita hentikan proses ini ketika kita sudah mencapai _leaf_ (tidak bisa mencabang
lebih jauh). _Leaf_ ditandai apabila seluruh _instance_ pada cabang tersebut
memiliki kelas yang sama. Atribut yang sudah dipilih pada _ancestor_ tidak
akan dicoba pada percabangan di cabang tertentu.
Sebagai contoh, perhatikanlah Gambar 6.1 yang merupakan hasil ID3
untuk Tabel 6.1. Bentuk elips merepresentasikan nama atribut, sementara
_edge_ (panah) merepresentasikan nilai atribut. Bentuk segi empat merepresentasikan
klasifikasi kelas ( _leaf_ ). Pohon keputusan pada Gambar 6.1 dapat
dikonversi menjadi kumpulan aturan klasifikasi berbentuk logika preposisi
dengan menelusuri setiap cabang pada pohon tersebut, yaitu:
- if _outlook=sunny_ and _humidity=high_ then _play=no_
- if _outlook=sunny_ and _humidity=normal_ then _play=yes_
- if _outlook=overcast_ then _play=yes_
- if _outlook=rainy_ and _windy=false_ then _play=yes_
- if _outlook=rainy_ and _windy=true_ then _play=no_
Karena _decision tree_ dapat interpretasikan sebagai logika preposisi, model ini
tergolong _interpretable_. Artinya, manusia dapat mengerti proses yang terjadi
pada model dengan mudah.
Pada setiap langkah membangun ID3, kita menggunakaninformation
gainuntuk memilih kandidat atribut terbaik. _Information gain_ mengukur
kemampuan suatu atribut untuk memisahkan _training data_ berdasarkan kelas
[7].
Sebelum masuk ke perumusan _information gain_, penulis akan mengingatkan _entropy_ terlebih
dahulu. Entropy (derajat ketidakteraturan) adalah
informasi yang dibutuhkan untuk memprediksi sebuah kejadian, diberikan
distribusi probabilitas. Secara matematis, entropy didefinisikan pada persamaan
6.1 (xadalah kumpulan nilai probabilitas).
```
_entropy_ (x) =−
```
#### ∑N
```
i=1
```
```
xilogxi (6.1)
```
Kita juga definisikanInfo sebagai persamaan 6.2, dimana ci adalah
banyaknya instance diklasifikasikan sebagai kelas ke-i (atau secara lebih
umum, ke _node_ -i).
86 6 Pohon Keputusan
```
Info(c 1 ,c 2 ,...,cN) = entropy(
```
```
c 1
∑N
j cj
```
#### ,
```
c 2
∑N
j cj
```
#### ,...,
```
cN
∑N
j cj
```
#### ) (6.2)
_Information gain_ dihitung sebagai persamaan 6.3, dimanaciadalah jumlah _instance_ untuk
kelas ke-i,vadalah nilai atribut,cvadalah banyaknya
_instance_ ketika dicabangkan dengan nilai atributv,cvxadalah banyaknya
_instance_ kelas saat percabangan. _Information gain_ dapat dimaknai sebagai
pengurangan entropy karena melakukan percabangan.
```
IG(c 1 ,c 2 ,...,cN) = Info(c 1 ,c 2 ,...,cN)−
```
#### ∑
```
vV
```
```
cv
∑N
i=1ci
```
```
Info(c 1 v,c 2 v,...,cNv)
```
(6.3)
Sebagai contoh, mari kita hitung _Information gain_ untuk atribut _outlook_
sebagai _root_. Dari keseluruhan data terdapat 9 _instance_ untuk _play=yes_ dan
5 instanceuntuk _play=no_. Kita hitung Info semesta sebagai (logbasis 2)
```
Info([9,5]) = entropy
```
#### ([
#### 9
#### 14
#### ,
#### 5
#### 14
#### ])
#### =−
#### 9
#### 14
```
log
```
#### (
#### 9
#### 14
#### )
#### −
#### 5
#### 14
```
log
```
#### (
#### 5
#### 14
#### )
#### = 0. 940
Kita hitung _entropy_ untuk masing-masing nilai atribut _outlook_ sebagai berikut:
- outlook=sunny
Ada dua _instance_ dengan _play=yes_ dan tiga _instance_ dengan _play=no_
saat _outlook=sunny_, dengan demikian kita hitung Info-nya.
```
Info([2,3]) = entropy
```
#### (
#### 2
#### 5
#### ,
#### 3
#### 5
#### )
#### =−
#### 2
#### 5
```
log
```
#### (
#### 2
#### 5
#### )
#### −
#### 3
#### 5
```
log
```
#### (
#### 3
#### 5
#### )
#### = 0. 971
- outlook=overcast
Ada empat _instance_ dengan _play=yes_ dan tidak ada _instance_ dengan
play=nosaat _outlook=overcast_, dengan demikian kita hitung Info-nya.
```
Info([4,0]) = entropy
```
#### (
#### 4
#### 4
#### ,
#### 0
#### 4
#### )
#### =−
#### 4
#### 4
```
log
```
#### (
#### 4
#### 4
#### )
#### −
#### 0
#### 4
```
log
```
#### (
#### 0
#### 4
#### )
#### = 0
```
Perhatikan log 0 pada matematika adalah tidak terdefinisi, tapi kita
anggap 0 log 0 sebagai 0 dalam komputasi.
```
```
6.2 ID3 87
```
- outlook=rainy
Ada tiga _instance_ dengan _play=yes_ dan dua _instance_ dengan _play=no_
saat _outlook=rainy_, dengan demikian kita hitung Info-nya.
```
Info([3,2]) = _entropy_
```
#### (
#### 3
#### 5
#### ,
#### 2
#### 5
#### )
#### =−
#### 3
#### 5
```
log
```
#### (
#### 3
#### 5
#### )
#### −
#### 2
#### 5
```
log
```
#### (
#### 2
#### 5
#### )
#### = 0. 971
Kita hitung _information gain_ untuk atribut _outlook_ sebagai
```
IG( _outlook_ ) = Info ([9,5])−
(
5
14
```
```
×Info ([3,2]) +
```
#### 4
#### 14
```
×Info([4,0]) +
```
#### 5
#### 14
```
×Info([3,2])
```
#### )
#### = 0. 940 −
#### (
#### 5
#### 14
#### × 0 .971 +
#### 4
#### 14
#### ×0 +
#### 5
#### 14
#### × 0. 971
#### )
#### = 0. 940 − 0. 693
#### = 0. 247
Dengan metode yang sama, kita hitung _information gain_ untuk atribut lain-
nya.
- IG(temperature) = 0. 029
- IG( _humidity_ ) = 0. 152
- IG(windy) = 0. 048
Dengan demikian, kita memilih atribut _outlook_ sebagai _root_.
Kita lanjutkan lagi membuat _subtree_ setelah memilih atribut _outlook_ sebagai _root_.
Kita hitung atribut yang tepat pada cabangoutook=sunny, seperti
diilustrasikan pada Gambar 6.2.
Pada _outlook=sunny_, terdapat dua _instance_ dengan kelas _play=yes_
dan tiga _instance_ dengan kelas _play=no_. Kita hitung _information gain_ saat
melanjutkan cabang dengan atribut _humidity_.
```
IG( _humidity_ ) = Info([2,3])−
```
#### (
#### 3
#### 5
```
×Info([0,3]) +
```
#### 2
#### 5
```
×Info([2,0])
```
#### )
#### = 0. 971 − 0
#### = 0. 971
Untuk setiap kedalaman, kita coba menggunakan atribut yang belum pernah
dicoba pada level-level lebih atas, seperti yang sudah diilutrasikan. Proses ini
dilanjutkan sampai kita tidak bisa atau tidak perlu mencabang lagi.
88 6 Pohon Keputusan
```
Gambar 6.2: Percabangan
```
|
### 6.4 Pembagian Ruang Konsep
Ada hubungan antara algorithma _decision tree_ dan model linear. Pada model
linear, kita semacam membagi-bagi ruang konsep (semesta data) menjadi ruang
per kelas menggunakan garis pembatas linear. _Decision tree_ melakukan
hal yang hampir sama, karena percabangan _decision tree_ dapat dianggap sebagai
linear. Sebagai contoh perhatikan ilustrasi Gambar 6.3, dimana semesta
adalah suatu ruang konsep. Tiap ruang merepresentasikan suatu cabang (dari
_root_ sampai leaf) pada _decision tree_. Garis-garis yang membentuk ruangruang
pemisah disebut sebagai _decision boundary_.
```
6.4 Pembagian Ruang Konsep 89
```
```
Gambar 6.3: Ilustrasi pembagian ruang konsep
```
|
### Soal Latihan
10.1. Intra- _cluster_ Evaluation
Buktikan kebenaran persamaan 10.7.
10.2. Entropy
Bagaimana cara menghitung kualitas algoritma _clustering_, jika diberikan informasi
label/ kelas setiap data menggunakan: (hint, baca [41])
(a) Entropy
(b) Purity
10.3. Kompleksitas
Hitunglah kompleksitas algoritma untuk:
(a) K- _mean_ s
(b) Agglomerative Clustering
(c) Divisive Clustering
10.4. Kemiripan Data
Sebutkanlah contoh perhitungan kemiripan untuk data _string_. Bagaimana
adaptasi perhitungan tersebut pada formula-formula yang sudah diberikan
pada algoritma K- _mean_ s dan agglomerative clustering.
10.5. Agglomerative vs Divisive Clustering
Menurut kamu, mengapa pendekatan _bottom-up_ (agglomerative) lebih populer
dibanding _top-down_ (divisive)? Apa perbedaan kedua pendekatan tersebut
(keuntungan dan kerugian masing-masing)?
10.6. Agglomerative Link
Jelaskan apa kelebihan dan kekurangan masing-masing metode perhitungan
kemiripan cluster pada agglomerative clustering!
|
### 10.3 Evaluasi
Diberikan sekumpulan dataD={d 1 ,d 2 ,···,dN}untuk suatu _cluster_. Saat
tidak tersedianya informasi label/kelas untuk setiap data, kualitas hasil _clustering_ dapat
dihitung dengan tiga kriteria yaitu:
```
1. _Intra-cluster similarity_, yaitu menghitung rata-rata kedekatan antara
suatu anggota dan anggota _cluster_ lainnya.
```
```
I=
```
#### 1
#### N^2
#### ∑
```
didj,i 6 =j
```
```
cosSim(di,dj) (10.6)
```
```
Perhitungan kedekatan antar tiap pasang anggota _clusters_ ama halnya
dengan menghitung _norm_ dari centroid _cluster_ tersebut, ketika centroid
dihitung menggunakan _mean_ (buktikan!).
```
```
I=
```
#### 1
#### N^2
#### ∑
```
didj,i 6 =j
```
```
cosSim(di,dj) =‖c‖^2 (10.7)
```
```
Perhitungan ini dapat di _norm_ alisasi sesuai dengan banyaknya anggota
_cluster_
I′=
‖c‖^2
N
```
#### (10.8)
```
Semakin tinggi kemiripan anggota pada suatu _cluster_, semakin baik kualitas
_cluster_ tersebut.
```
```
2. _Inter-cluster similarity_, yaitu menghitung bagaimana perbedaan antara
suatu _cluster_ dan _cluster_ lainnya. Hal tersebut dihitung dengancosine
similarity antara centroid suatu _cluster_ dan centroid dari seluruh
_data_ [42], dimanackadalah centroid _cluster_ ke-k,cDadalah centroid
( _mean_ ) dari seluruh data,Nkadalah banyaknya anggota _cluster_ ke-k, dan
Kadalah banyaknya _clusters_. Semakin kecil nilai _inter-cluster similarity_,
maka semakin baik kualitas _clustering_.
```
#### E=
#### ∑K
```
k=1
```
```
Nk
ckcD
‖ck‖
```
#### (10.9)
```
3. _Hybrid_. Perhitungan intra- _cluster_ dan inter- _cluster_ mengoptimalkan
satu hal sementara tidak memperdulikan hal lainnya. _Intra-cluster_ menghitung
keeratan anggota _cluster_, sementara _Inter-cluster_ menghitung separasi
antar _clusters_. Kita dapat menggabungkan keduanya sebagai _hybrid_
(gabungan), dihitung dengan:
```
#### H=
#### ∑K
```
k=1I
′
k
E
```
#### =
#### ∑K
```
k=1
```
```
‖ck‖^2
Nk
∑K
k=1Nk
```
```
ckcD
‖ck‖
```
#### =
#### ∑K
```
k=1
```
```
‖ck‖
Nk^2 ckcD
```
#### (10.10)
```
Semakin besar nilai perhitungan _hybrid_, semakin bagus kualitas _clusters_.
```
140 10 Clustering
Apabila terdapat informasi label/ kelas untuk setiap data, kita juga dapat
menghitung kualitas algoritma _clustering_ (perhatikan! tujuan pengukuran
adalah kualitas algoritma) dengan _Entropy_ danPurity.
|
### 10.2 Hierarchical Clustering
Hierarchical clusteringadalah teknik untuk membentuk pembagian bersarang
(nested partition). Berbeda dengan K- _mean_ s yang hasil _clustering_ -nya berbentukflatatau
rata, _hierarchical clustering_ memiliki satu _cluster_ paling atas
yang mencakup konsep seluruh _cluster_ dibawahnya. Ada dua cara untuk membentuk _hierarchical_
_clustering_ [41]:
```
1.Agglomerative. Dimulai dari beberapaflat clusters; pada setiap langkah
iterasi, kita menggabungkan dua _clusters_ termirip. Artinya, kita harus
mendefinisikan arti “kedekatan” dua _clusters_.
```
```
2.Divisive. Dimulai dari satu _cluster_ (seluruh data), kemudian kita memecah
belah _cluster_. Artinya, kita harus mendefinisikan _cluster_ mana yang harus
dipecah dan bagaimana cara memecahnya.
```
```
Gambar 10.1: Ilustrasi _hierarchical clustering_.
```
(^1) https://en.wikipedia.org/wiki/Cosine_similarity
138 10 Clustering
Sebagai contoh, algoritma _hierarchical clustering_ menghasilkan struktur
hirarkis seperti pada gambar 10.1 yang disebutdendogram. Dendogram
melambangkan taksonomi, sebagai contoh taksonomi dokumen berita _sport_,
dipecah menjadi _baseball_ dan _soccer_.
Sejauh ini, teknik _agglomerative clustering_ lebih populer, karena pendekatan
ini bersifat _bottom-up_. Secara umum, pendekatan _bottom-up_ memang
relatif lebih populer dibanding pendekatan _top-down_. Langkah-langkahagglomerative
_clustering_ sebagai berikut:
1. Sediakan sebanyakK _cluster_. Kamu dapat menganggap satu _instance_ data
sebagai satu _cluster_.
2. Gabung dua _clusters_ paling mirip.
3. Ulangi langkah ke-2 sampai hanya satu _cluster_ tersisa.
Perhatikan, untuk menggabungkan dua _clusters_ termirip, kita membutuhkan
definisi “mirip”. Definisi tersebut dikuantifikasi dengan formula matematis
(seperti definisi kemiripan data pada subbab 10.1). Perhitungan kemiripan _clusters_ dapat
dihitung dengan tiga metode [43] (untuk data numerik):
```
1. _Single Link_. Nilai kemiripan dua _clusters_ UdanVdihitung berdasarkan
nilai kemiripanmaksimumdiantara anggota kedua _clusters_ tersebut^2.
```
```
SimsingleLink(U,V) = max
ui∈U,vj∈V
cosSim(ui,vj) (10.3)
```
```
2. _Complete Link_. Nilai kemiripan dua _clusters_ dihitung berdasarkan nilai
kemiripanminimumdiantara anggota kedua _clusters_ tersebut.
```
```
SimcompleteLink(U,V) = min
ui∈U,vj∈V
cosSim(ui,vj) (10.4)
```
```
3.UPGMA ( _Average Link_ ). Nilai kemiripan dua _clusters_ dihitung berdasarkan
nilai kemiripanrata-ratadiantara anggota kedua _clusters_ tersebut.
```
```
SimUPGMA(U,V) =
```
#### 1
#### |U||V|
#### ∑
```
ui∈U,vj∈V
```
```
cosSim(ui,vj) =
cUcV
|U||V|
```
#### (10.5)
```
dimana|U|adalah banyaknya data pada _cluster_ UdancUadalah centroid
untuk _cluster_ U.
```
(^2) Clusterdapat dianggap sebagai matriks karena merupakan kumpulanfeature vec-
tor.
```
10.3 Evaluasi 139
```
|
### 10.1 K- _mean_ s, Pemilihan Centroid, Kemiripan Data
Algoritma K- _mean_ s mengelompokkan data menjadi sebanyakK kelompok
sesuai yang kita definisikan. Algoritma ini disebut juga sebagai _flat clustering_,
artinya kelompok satu memiliki kedudukan sejajar dengan kelompok lainnya.
Kita tinjau kembali tahapan-tahapan algoritma K- _mean_ s sebagai berikut:
1. Tentukan sebanyakKkelompok yang kita inginkan.
2. Inisiasi _centroid_ untuk setiap kelompok. Centroid ibarat seperti “ketua
kelompok”, yang merepresentasikan kelompok.
3. Hitung kedekatan suatu data terhadap _centroid_, kemudian masukkan data
tersebut ke kelompok yang _centroid_ -nya memiliki sifat terdekat dengan
dirinya.
4. Pilih kembali centroid untuk masing-masing kelompok, yaitu dari anggota
kelompok tersebut.
5. Ulangi langkah-langkah sebelumnya sampai tidak ada perubahan anggota
untuk semua kelompok.
Perhatikan, ada dua hal penting pada algoritma K- _mean_ s yaitu: (1)
memilih centroid dan (2) Perhitungan kemiripan data. Pada bab 4, dijelaskan
salah satu metode pemilihan centroid paling sederhana yaitu secara acak.
Pada kenyataannya, inisiasi centroid untuk setiap kelompok/ _cluster_ dapat dilakukan
secara acak; tetapi pada tahap berikutnya, secara umum centroid
dipilih menggunakan nilai rata-rata/ _mean_. Dengan demikian, centroid bisa
saja merupakan suatu vektor yang tidak ada _entry_ -nya di dataset.
Diberikan sekumpulan dataD={d 1 ,d 2 ,···,dN}; maka centroidcuntuk
_cluster_ itu dihitung dengan persamaan 10.1,
```
c=
```
#### 1
#### N
#### ∑N
```
i=1
```
#### ∑F
```
e=1
```
```
di[e] (10.1)
```
yaitu nilai rata-rata setiap elemen _feature vector_ untuk seluruh anggota _cluster_
tersebut, dimanaN adalah banyaknya anggota _cluster_,F adalah dimensi
_vektor_,diadalah anggota ke-i dalam representasi _feature vector_ dandi[e]
melambangkan elemen ke-epada vektordi. Dengan ini, centroid secara umum
bisa jadi tidak merupakan elemen anggota _cluster_ ( _centroid_ bukan sebuah
_instance_ data).
Pada bab 4 dijelaskan salah satu metode perhitungan kemiripan data
sederhana yaitu dengan menghitung banyaknya nilai atribut yang sama diantara
dua _feature vector_. Selain metode tersebut, terdapat banyak perhitungan
kemiripan data lainnya tergantung pada tipe, contohnya:
```
1.Numerik. Euclidean Distance, Manhattan Distance, Cosine Distance,
dsb.
2.Boolean. Jaccard Dissimilarity, Rogers Tanimoto Dissimilarity, dsb.
3.String. Levenshtein Distance, Hamming Distance, dsb.
```
```
10.2 Hierarchical Clustering 137
```
Perhitungan yang paling populer digunakan adalah _cosine similarity_ ^1 (kebetulan
pada kebanyakan kasus kita bekerja dengan data numerik), didefinisikan
pada persamaan 10.2, yaitu _dot product_ antara dua vektor dibagi dengan
perkalian _norm_ kedua vektor.
```
cosSim(di,dj) =
di·dj
‖di‖‖dj‖
```
#### (10.2)
_Cluster_ s yang terbentuk, nantinya dapat digunakan sebagai pengelompokkan
untuk label klasifikasi. Seumpama _cluster_ 1 dapat dianggap sebagai data untuk
kelas ke-1, dst.
|
### 10.3 Evaluasi
Diberikan sekumpulan dataD={d 1 ,d 2 ,···,dN}untuk suatu _cluster_. Saat
tidak tersedianya informasi label/kelas untuk setiap data, kualitas hasil _clustering_ dapat
dihitung dengan tiga kriteria yaitu:
```
1. _Intra-cluster similarity_, yaitu menghitung rata-rata kedekatan antara
suatu anggota dan anggota _cluster_ lainnya.
```
```
I=
```
#### 1
#### N^2
#### ∑
```
didj,i 6 =j
```
```
cosSim(di,dj) (10.6)
```
```
Perhitungan kedekatan antar tiap pasang anggota _clusters_ ama halnya
dengan menghitung _norm_ dari centroid _cluster_ tersebut, ketika centroid
dihitung menggunakan _mean_ (buktikan!).
```
```
I=
```
#### 1
#### N^2
#### ∑
```
didj,i 6 =j
```
```
cosSim(di,dj) =‖c‖^2 (10.7)
```
```
Perhitungan ini dapat di _norm_ alisasi sesuai dengan banyaknya anggota
_cluster_
I′=
‖c‖^2
N
```
#### (10.8)
```
Semakin tinggi kemiripan anggota pada suatu _cluster_, semakin baik kualitas
_cluster_ tersebut.
```
```
2. _Inter-cluster similarity_, yaitu menghitung bagaimana perbedaan antara
suatu _cluster_ dan _cluster_ lainnya. Hal tersebut dihitung dengancosine
similarity antara centroid suatu _cluster_ dan centroid dari seluruh
_data_ [42], dimanackadalah centroid _cluster_ ke-k,cDadalah centroid
( _mean_ ) dari seluruh data,Nkadalah banyaknya anggota _cluster_ ke-k, dan
Kadalah banyaknya _clusters_. Semakin kecil nilai _inter-cluster similarity_,
maka semakin baik kualitas _clustering_.
```
#### E=
#### ∑K
```
k=1
```
```
Nk
ckcD
‖ck‖
```
#### (10.9)
```
3. _Hybrid_. Perhitungan intra- _cluster_ dan inter- _cluster_ mengoptimalkan
satu hal sementara tidak memperdulikan hal lainnya. _Intra-cluster_ menghitung
keeratan anggota _cluster_, sementara _Inter-cluster_ menghitung separasi
antar _clusters_. Kita dapat menggabungkan keduanya sebagai _hybrid_
(gabungan), dihitung dengan:
```
#### H=
#### ∑K
```
k=1I
′
k
E
```
#### =
#### ∑K
```
k=1
```
```
‖ck‖^2
Nk
∑K
k=1Nk
```
```
ckcD
‖ck‖
```
#### =
#### ∑K
```
k=1
```
```
‖ck‖
Nk^2 ckcD
```
#### (10.10)
```
Semakin besar nilai perhitungan _hybrid_, semakin bagus kualitas _clusters_.
```
140 10 Clustering
Apabila terdapat informasi label/ kelas untuk setiap data, kita juga dapat
menghitung kualitas algoritma _clustering_ (perhatikan! tujuan pengukuran
adalah kualitas algoritma) dengan _Entropy_ danPurity.
|
### 11.6 Binary Classification
Salah satu st _rate_ gi untuk _binary classification_ adalah dengan menyediakan
hanya satu _output unit_ di jaringan. Kelas pertama direpresentasikan dengan
−1, kelas kedua direpresentasikan dengan nilai 1 (setelah diaktivasi). Hal ini
dapat dicapai dengan fungsi non-linear seperti sign^8 atau tanh.^9 Apabila kita
tertarik dengan probabilitas masuk ke dalam suatu kelas, kita dapat meng-
(^7) Karena struktur lebih susah, setidaknya beranjak dari keputusan terlebih dahulu
(^8) https://en.wikipedia.org/wiki/Sign_ _function_
(^9) https://en.wikipedia.org/wiki/Hyperbolic_ _function_
154 11 Feed _forward_ Neural Network
gunakan fungsi seperti sigmoid,^10 dimana _output_ pada masing-masing neuron
berada pada _range_ nilai [0,1].
|