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.
|
End of preview. Expand
in Dataset Viewer.
No dataset card yet
New: Create and edit this dataset card directly on the website!
Contribute a Dataset Card- Downloads last month
- 4