### 12.3 Ide Dasar Auto _encoder_

Seperti yang sudah dijelaskan _autoencoder_ adalah _neural network_ yang mampu
merekonstruksi _input_. Ide dasar _autoencoder_ tidak jauh dari konsep dekomposisi/di _mention_ ality
reductionmenggunakan _singular value decomposition_.
Diberikan datasetX, kita ingin mensimulasikan pencarian matriksXˆ yang
merupakan sebuah aproksimasi dari matriks asli. Arsitektur dasar _autoencoder_
diberikan pada Gambar 12.1. Kita memberi input matriksXpada _autoencoder_,
kemudian ingin _autoencoder_ tersebut menghasilkan matriks yang sama.
Dengan kata lain, _desired output_ sama dengan _input_. Apabila dihubungkan
dengan pembahasan ANN pada bab sebelumnya, _error function_ untuk melatih
_autoencoder_ diberikan pada persamaan 12.4, dimanayadalah output dari
jaringan danZadalah dimensi _output_,Nadalah banyaknya sampel danxi
adalah data ke-i( _feature vector_ ke-i).

```
12.3 Ide Dasar Auto _encoder_ 167
```
```
E(θ) =
```
#### 1

#### N

#### ∑Z

```
i=j
```
#### (

```
xi[j]−yi[j]
```
#### ) 2

#### (12.4)

Persamaan 12.4 dapat kita tulis kembali sebagai persamaan 12.5, dimanaf
melambangkan fungsi aktivasi danθadalah ANN (kumpulan _weight_ matri-
ces).^5

```
E(θ) =
```
#### 1

#### N

#### ∑Z

```
j=1
```
#### (

```
xi[j]−f(xi,θ)[j]
```
#### ) 2

#### (12.5)

Seperti yang sudah dijelaskan sebelumnya, _desired output_ sama dengan _input_.
Tetapi seperti yang kamu ketahui, mencapai _loss_ sebesar 0% adalah hal yang
susah. Dengan demikian, kamu dapat memahami secara intuitif bahwa _autoencoder_ melakukan
aproksimasi terhadap data asli, tetapi tidak sama persis.
Apabila _loss_ sebesar 0%, ditakutkan bahwa _autoencoder_ semata-mata hanya
melakukan translasi (penggesaran) data saja. Gambar 12.2 mengilustrasikan
hubungan antara _autoencoder_ dan _singular value decomposition_.^6 Perhatikan,
ada dua proses _encoding_ yaitu merepresentasikan data ke dimensi lebih rendah
dan _decoding_ –rekonstruksi kembali.

```
_Input_
( _feature vector_ )
```
```
_Output_
(reconstruction of feature vector)
```
```
Coding
```


### 12.4 Resisting Perturbation

Pada subbab sebelumnya, telah dijelaskan bahwa mencapai performa 100%
(100% rekonstruksi) pada _autoencoder_ adalah hal yang tidak diinginkan. Hal
ini disebabkan karena kita ingin menghindari _autoencoder_ semata-mata hanya
mempelajari _trivial identity function_ [11], memiliki analogi denganone-toone
mapping. Misalnya, suatu gambar kuda dipetakan ke _coding_ c, kemudian
gambar kuda lainnya dipetakan ke _coding_ ˆc, danˆctidak mirip denganc, i.e.,
_cosine similarity_ -nya jauh. Artinya kita ingin _autoencoder_ merepresentasikan
dua hal yang mirip ke dalam bentuk representasi _coding_ yang mirip juga!
Walaupun kita ingin performa _autoencoder_ tidak mencapai 100%, tapi kita
masih ingin performanya dekat dengan 100%.
Tujuan utama _autoencoder_ adalah mengekstraksi informasi penting tentang
_data_  yang ada (seperti _principal components_ ), bukan replikasi semata.
Dengan alasan ini, _coding_ pada umumnya memiliki dimensi lebih rendah
dibanding _input_. Kita sebut arsitektur ini sebagai _undercomplete autoencoder_.
Apabila _coding_ memiliki dimensi lebih besar dari _input_, disebut sebagaiovercomplete
_autoencoder_ –yang kemungkinan besar hanya mempelajaritrivial
identity function[11]. Kita dapat menggunakan teknik regularisasi
pada _autoencoder_ untuk memastikan tujuan kita tercapai, misal
_sparse autoencoder_, _denoising autoencoder_ dan _penalizing derivaties_ [11]. Untuk
mengilustrasikan permasalahan, buku ini membahas _denoising autoencoder_ (silahkan
baca buku [11] untuk teknik regularisasi lainnya).
Diberikan suatu _input_ x, kemudian kita lakukan _noise-injection_ terhadap
_input_ tersebut, menghasilkan ̃x. Perhatikan Gambar 12.3, kita ingin _encoder_
memberikan bentuk _coding_ yang mirip bagixdan ̃x. Kita ingin memaksa _autoencoder_ untuk
mempelajari sebuah fungsi yang tidak berubah terlalu jauh
ketika _inputs_ edikit diubah. Hal ini disebut sebagai sifat _resistance to perturbation_.
Performa _autoencoder_ yang bernilai 100% berbahaya karena _autoencoder_ tersebut
belum tentu mampu mempelajari sifat data, melainkan
mampu “mengingat” _training data_ saja ( _mapping table_ ). Objektifdenoising
_autoencoder_ diberikan pada persamaan 12.9, yaitu kemampuan merekonstruksi
kembali data tanpa _noise_.

```
E(θ) =
```
#### 1

#### N

#### ∑Z

```
j=1
```
#### (

```
xi[j]−f( ̃xi,θ)[j]
```
#### ) 2

#### (12.9)

170 12 Auto _encoder_

```
Gambar 12.3:Resisting Perturbation.
```
Gambar 12.4: _Autoencoder_ yang memiliki sifat _resistance to perturbation_,
yaitu invarian terhadap sedikit perubahan.

```
Gambar 12.5:Mani _fold_ s.
```
Implikasi atau tujuan dari persamaan 12.9 diberikan pada Gambar 12.4
yang mengilustrasikan _invariant to slight changes_. Diberikan data dengan dis-

(^8) https://jaan.io/what-is-variational- _autoencoder_ -vae-tutorial/

```
12.5 Representing Context: Word Embedding 171
```
tribusi aslip _data_, dan data yang sudah terkena _noise_ ̃x, _autoencoder_ mampu
mengembalikan ̃xke bentuk aslix. Sebagai ilustrasi yang lebih “global”, perhatikan
Gambar 12.5 dimana suatu elips melambangkan _manifolds_, dimana
_data_  yang mirip (e.g., kuda dengan berbagai macam pose) berada pada ruang
yang cukup dekat satu sama lain. Kamu dapat memahamiresistance to
perturbationmembuat _autoencoder_ membentuk semacam “ruang lokal” yang
merepresentasikan suatu data dan variannya.


### CBOW Skip-gram

Gambar 12.8: CBOW ( _Continous bag of words_ ) vs Skip-gram, rekonstruksi
[49].

```
Si Kucingduduk ...tiker
```
```
Projection
(Embedding)
```
```
beralaskan
```
```
Gambar 12.9: CBOW.
```

```
12.5 Representing Context: Word Embedding 177
```
level abstrak, yaitu merepresentasikan kata dan konteksnya menjadi bentuk
_vektor_. Apabila kamu tertarik untuk memahami detilnya secara matematis,
kamu dapat membaca berbagai penelitian terkait.^14 Silahkan baca _paper_ oleh
Mikolov [48, 49] untuk detil implementasi _word embedding_.

12.5.4 Distributed Sentence Representation

Kita sudah dapat merepresentasikan kata menjadi vektor, selanjutnya kita
ingin mengonversi unit lebih besar (kalimat) menjadi vektor. Salah satu cara
paling mudah adalah menggunakan nilai rata-rata representasi _word embedding_ untuk
semua kata yang ada pada kalimat tersebut ( _average_ of its individual
_word embedding_ s). Cara ini sering digunakan pada bidang NLP dan cukup
_powerful_, sebagai contoh pada _paper_ oleh Putra dan Tokunaga [75]. Pada NLP,
sering kali kalimat diubah terlebih dahulu menjadi vektor sebelum dilewatkan
pada algoritma _machine learning_, misalnya untuk analisis sen _time_ n (kalimat
bersen _time_ n positif atau negatif). Vektor ini yang nantinya menjadifeature
vectorbagi algoritma _machine learning_.
Kamu sudah tahu bagaimana cara mengonversi kata menjadi vektor, untuk
mengonversi kalimat menjadi vektor cara sederhananya adalah merataratakan
nilai vektor kata-kata pada kalimat tersebut. Tetapi dengan cara
sederhana ini, sifat sekuensial dan _compositional_ pada kalimat tidak terpenuhi.
Sebagai contoh, kalimat “anjing menggigit Budi” dan “Budi menggigit
anjing” akan direpresentasikan sebagai vektor yang sama karena terdiri
dari kata-kata yang sama. Dengan demikian, representasi kalimat sederhana
dengan merata-ratakan vektor kata-katanya juga tidaklah sensitif terhadap
urutan.^15 Selain itu, rata-rata tidak sensitif terhadap _compositionality_. Misal
frase “bukan sebuah pengalaman baik” tersusun atas frase “bukan” yang diikuti
oleh “sebuah pengalaman baik”. Rata-rata tidak mengetahui bahwa
“bukan” adalah sebuah _modifier_ untuk sebuah frase dibelakangnya. Sen _time_ n
dapat berubah bergantung pada komposisi kata-katanya (contoh pada
Gambar 12.10).
Cara lainnya adalah meng- _encode_ kalimat sebagai _vektor_ menggunakan
_recursive autoencoder_. _Recursive_ berarti suatu bagian adalah komposisi dari
bagian lainnya. Penggunaan _recursive autoencoder_ sangat rasional berhubung
_data_  memenuhi sifat _compositionality_ yang direpresentasikan dengan baik oleh
topologi _recursive neural network_. Selain itu, urutan susunan kata-kata juga
tidak hilang. Untuk melatih _recursive autoencoder_, _output_ dari suatu layer
adalah rekonstruksi _input_, ilustrasi dapat dilihat pada Gambar 12.11. Pada
setiap langkah _recursive_, _hidden layer/coding layer_ berusaha men- _decode_ atau
merekonstruksi kembali vektor _input_.
Lebih jauh, untuk sen _time_ n analisis pada kata, kita dapat menambahkan
_output_  pada setiap _hidden layer_, yaitu sen _time_ n unit gabungan, seperti pada

(^14) Beberapa orang berpendapat bahwa _evil is in the detail_.
(^15) Karena ini _recurrent neural network_ bagus untuk _language modelling_.
(^16) [http://nlp.stanford.edu:8080/sen _time_ nt/rntnDemo.html](http://nlp.stanford.edu:8080/sen _time_ nt/rntnDemo.html)

178 12 Auto _encoder_

```
Gambar 12.10: Contoh analisis sen _time_ n (Stanford).^16
```
```
Gambar 12.11: Contoh recursive auto _encoder_.
```
Gambar 12.12. Selain menggunakan _recursive autoencoder_, kamu juga dapat
menggunakan _recurrent autoencoder_. Kami silahkan pada pembaca untuk
memahami _recurrent autoencoder_. Prinsipnya mirip dengan _recursive_ autoen-
coder.
Teknik yang disampaikan mampu mengonversi kalimat menjadi vektor,
lalu bagaimana dengan paragraf, satu dokumen, atau satu frasa saja? Teknik
umum untuk mengonversi teks menjadi vektor dapat dibaca pada [69] yang
lebih dikenal dengan nama _paragraph vector_ atau _doc2vec_.

```
12.6 Tips 179
```
```
Gambar 12.12: Contoh recursive auto _encoder_ dengan sen _time_ nt[67].
```


### 12.6 Tips

Bab ini menyampaikan penggunaan _neural network_ untuk melakukankompresi
_data_ ( _representation learning_ ) dengan teknik _unsupervised learning_. Hal
yang lebih penting untuk dipahami bahwa ilmu _machine learning_ tidak berdiri
sendiri. Walaupun kamu menguasai teknik machine learning tetapi tidak
mengerti domain dimana teknik tersebut diaplikasikan, kamu tidak akan bisa
membuat _learning machine_ yang memuaskan. Contohnya, pemilihan fiturmachine
_learning_ pada teks (NLP) berbeda dengan gambar ( _computer vision_ ).
Mengerti _machine learning_ tidak semata-mata membuat kita bisa menyelesaikan
semua macam permasalahan. Tanpa pengetahuan tentang domain aplikasi,
kita bagaikan orang buta yang ingin menyetir sendiri!


### Soal Latihan

12.1. Penggunaan Auto _encoder_ untuk Arsitektur Kompleks

(a) Pada bab ini, telah dijelaskan bahwa kita dapat menginisialisasi arsitektur
_neural network_ yang kompleks menggunakan _autoencoder_. Jelaskan pada
kasus apa kita dapat melakukan hal tersebut!
(b) Jelaskan mengapa menginisiasi (sebagian) arsitektur kompleks menggunakan _autoencoder_ adalah
sesuatu yang masuk akal!

12.2. LSI dan LDA

```
(a) Jelaskanlah Latent Semantic Indexing (LSI) dan Latent Dirichlet Allocation
(LDA)!
```

180 12 Auto _encoder_

(b) Apa persamaan dan perbedaan antara LSI, LDA, dan _autoencoder_ ?

12.3. Variational Auto _encoder_
Jelaskan apa itu _variational autoencoder_ ! Deskripsikan perbedaannya dengan
_autoencoder_ yang sudah dijelaskan pada bab ini?


### 12.5 Representing Context: Word Embedding

Subbab ini menceritakan salah satu aplikasi _autoencoder_. Pada domain NLP,
kita ingin komputer mampu mengerti bahasa selayaknya manusia mengerti
bahasa. Misalkan komputer mampu mengetahui bahwa “meja” dan “kursi”
memiliki hubungan yang erat. Hubungan seperti ini tidak dapat terlihat
berdasarkan teks tertulis, tetapi kita dapat menyusun kamus hubungan kata
seperti WordNet.^9 WordNet memuat ontologi kata seperti hipernim, antonim,
sinonim. Akan tetapi, hal seperti ini tentu sangat melelahkan, seumpama ada
kata baru, kita harus memikirkan bagaimana hubungan kata tersebut terhadap
seluruh kamus yang sudah dibuat. Pembuatan kamus ini memerlukan
kemampuan para ahli linguistik.
Oleh sebab itu, kita harus mencari cara lain untuk menemukan hubungan
kata ini. Ide utama untuk menemukan hubungan antarkata adalah _statistical_
semantics hypothesisyang menyebutkan pola penggunaan kata dapat
digunakan untuk menemukan arti kata [74]. Contoh sederhana, kata yang
muncul pada “konteks” yang sama cenderung memiliki makna yang sama.
Perhatikan “konteks” dalam artian NLP adalah kata-kata sekitar (surrounding
_word_ s);^10 contohnya kalimat “ _budi menendang bola_ ”, “konteks” dari “bola”
adalah “budi menendang”. Kata “cabai” dan “permen” pada kedua kalimat
“budi suka cabai” dan “budi suka permen” memiliki kaitan makna, dalam
artian keduanya muncul pada konteks yang sama. Sebagai manusia, kita tahu
ada keterkaitan antara “cabai” dan “permen” karena keduanya bisa dimakan.
Berdasarkan hipotesis tersebut, kita dapat mentransformasi kata menjadi
sebuah bentuk matematis dimana kata direpresentasikan oleh pola penggunaannya
[64]. Arti kata _embedding_ adalah transformasi kata (beserta konteksnya)
menjadi bentuk matematis ( _vektor_ ), i.e., mirip/sama dengan _coding_.
“Kedekatan hubungan makna” ( _semantic relationship_ ) antarkata kita
harapkan dapat tercermin pada operasi vektor. Salah satu metode sederhana
untuk merepresentasikan kata sebagai vektor adalahVector Space
Model. Konsep _embedding_ dan _autoencoder_ sangatlah dekat, tapi kami ingin
menakankan bahwa _embedding_ adalah bentuk representasi konteks.

(^9) https:// _word_ net.princeton.edu/
(^10) Selain _surrounding words_, konteks dalam artian NLP dapat juga berupa kalimat,
paragraph, atau dokumen.

172 12 Auto _encoder_

```
Dokumen 1 Dokumen 2 Dokumen 3 Dokumen 4···
King 1 0 0 0 ···
Queen 0 1 0 1 ···
Prince 1 0 1 0 ···
Princess 0 1 0 1 ···
···
```
```
Tabel 12.1: Contoh 1-of-V en _coding_.
```
_Semantic relationship_  dapat diartikan sebagai attributional atau
_relational similarity_. _Attributional similarity_ berarti dua kata memiliki
atribut/sifat yang sama, misalnya anjing dan serigala sama-sama berkaki empat,
menggongong, serta mirip secara fisiologis. _Relational similarity_ berarti
derajat korespondensi, misalnyaanjing:menggongongmemiliki hubungan
yang erat dengankucing:mengeong.

12.5.1 Vector Space Model

_Vector space model_  (VSM)^11 adalah bentuk _embedding_ yang relatif sudah
cukup lama tapi masih digunakan sampai saat ini. Pada pe _model_ an ini, kita
membuat sebuah matriks dimana baris melambangkan kata, kolom melambangkan
dokumen. Metode VSM ini selain mampu menangkap hubungan antarkata
juga mampu menangkap hubungan antardokumen ( _to some degree_ ).
Asal muasalnya adalah _statistical semantics hypothesis_. Tiap sel pada matriks
berisi nilai 1 atau 0. 1 apabilakataimuncul didokumenidan 0 apabila tidak.
Model ini disebut _1-of-V/1-hot encoding_ dimanaV adalah ukuran kosa
kata. Ilustrasi dapat dilihat pada Tabel 12.1.
Akan tetapi, _1-of-V encoding_ tidak menyediakan banyak informasi untuk
kita. Dibanding sangat ekstrim saat mengisi sel dengan nilai 1 atau 0 saja, kita
dapat mengisi sel dengan frekuensi kemunculan kata pada dokumen, disebut
_term frequency_ (TF). Apabila suatu kata muncul pada banyak dokumen,
kata tersebut relatif tidak terlalu ”penting” karena muncul dalam berbagai
konteks dan tidak mampu membedakan hubungan dokumen satu dan dokumen
lainnya ( _inverse document frequency_ /IDF). Formula IDF diberikan
pada persamaan 12.10. Tingkat kepentingan kata berbanding terbalik dengan
jumlah dokumen dimana kata tersebut dimuat.Nadalah banyaknya dokumen,|dD;td|adalah
banyaknya dokumen dimana katatmuncul.

```
IDF(t,D) = log
```
#### (

#### N

```
|dD;td|
```
#### )

#### (12.10)

Dengan menggunakan perhitungan TF-IDF yaituTF×IDFuntuk mengisi
sel pada matriks Tabel 12.1, kita memiliki lebih banyak informasi. TF-IDF

(^11) Mohon bedakan dengan VSM ( _vector space model_ ) dan SVM ( _support vector_
machine)

```
12.5 Representing Context: Word Embedding 173
```
sampai sekarang menjadi _baseline_ pada _information retrieval_. Misalkan
kita ingin menghitung kedekatan hubungan antar dua dokumen, kita hitung
_cosine distance_ antara kedua dokumen tersebut ( _vektor_ suatu dokumen
disusun oleh kolom pada matriks). Apabila kita ingin menghitung kedekatan
hubungan antar dua kata, kita hitung _cosine distance_ antara kedua kata tersebut
dimana vektor suatu kata merupakan baris pada matriks. Tetapi seperti
intuisi yang mungkin kamu miliki, mengisi _entry_ dengan nilai TF-IDF pun
akan menghasilkan _sparse matrix_.

```
_Statistical semantics hypothesis_  diturunkan lagi menjadi empat macam
hipotesis [74]:
1. _Bag of words_
2. _Distributional hypothesis_
3. _Extended distributional hypothesis_
4. _Latent relation hypothesis_
Silakan pembaca mencari sumber tersendiri untuk mengerti keempat hipotesis
tersebut atau membaca _paper_ Turney dan Pantel [74].
```
12.5.2 Sequential, Time Series dan Compositionality

Bahasa manusia memiliki dua macam karakteristik yaitu adalah data berbentuk _sequential_
_data_ dan memenuhi sifat _compositionality_. _Sequential data_
adalah sifat data dimana suatu kemunculan _data_ idipengaruhi oleh data sebelumnya
( _data_ i− 1 , _data_ i− 2 ,...). Perhatikan kedua kalimat berikut:

1. Budi melempar bola.
2. Budi melempar gedung bertingkat.

Pada kedua kalimat tersebut, kalimat pertama lebih masuk akal karena
bagaimana mungkin seseorang bisa melempar gedung bertingkat. Keputusan
kita dalam memilih kata berikutnya dipengaruhi oleh kata-kata sebelumnya,
dalam hal ini “Budi melempar” setelah itu yang lebih masuk akal adalah
“bola”. Contoh lain adalah data yang memiliki sifat _time series_ yaitu gelombang
laut, angin, dan cuaca. Kita ingin memprediksi data dengan rekaman
masa lalu, tapi kita tidak mengetahui masa depan. Kita mampu memprediksi
cuaca berdasarkan rekaman parameter cuaca pada hari-hari sebelumnya.
Ada yang berpendapat beda _time series_ dan _sequential_ (sekuensial) adalah
diketahuinya sekuens kedepan secara penuh atau tidak. Penulis tidak dapat
menyebutkan _time series_ dan sekuensial sama atau beda, silahkan pembaca
menginterpretasikan secara bijaksana.
Data yang memenuhi sifat _compositionality_ berarti memiliki struktur
hirarkis. Struktur hirarkis ini menggambarkan bagaimana unit-unit lebih kecil
berinteraksi sebagai satu kesatuan. Artinya, interpretasi/pemaknaan unit
yang lebih besar dipengaruhi oleh interpretasi/pemaknaan unit lebih kecil

174 12 Auto _encoder_

(subunit). Sebagai contoh, kalimat “saya tidak suka makan cabai hijau”. Unit
”cabai” dan ”hijau” membentuk suatu frasa ”cabai hijau”. Mereka tidak bisa
dihilangkan sebagai satu kesatuan makna. Kemudian interaksi ini naik lagi
menjadi kegiatan “makan cabai hijau” dengan keterangan “tidak suka”, bahwa
ada seseorang yang “tidak suka makan cabai hijau” yaitu “saya”. Pemecahan
kalimat menjadi struktur hirarkis berdasarkan _syntactical role_ disebutconstituent
parsing, contoh lebih jelas pada Gambar 12.6.Nadalah _noun_,D
adalah _determiner_,NPadalah _noun phrase_,VPadalah _verb phrase_, danS
adalah _sentence_. Selain bahasa manusia, gambar juga memiliki struktur hirarkis.
Sebagai contoh, gambar rumah tersusun atas tembok, atap, jendela,
dan pintu. Tembok, pintu, dan jendela membentuk bagian bawah rumah; lalu
digabung dengan atap sehingga membentuk satu kesatuan rumah.

```
Gambar 12.6: Contoh constituent tree.^12
```
12.5.3 Distributed Word Representation

Seperti yang disebutkan pada bagian sebelumnya, kita ingin hubungan kata
(yang di _infer_ ensi dari konteksnya) dapat direpresentasikan sebagai operasi
_vektor_  seperti pada ilustrasi Gambar 12.7. Kata “raja” memiliki sifat-sifat
yang dilambangkan oleh suatu vektor (misal 90% aspek loyalitas, 80% kebijaksanaan,
90% aspek kebangsaan, dst), begitu pula dengan kata “pria”,
“wanita”, dan “ratu”. Jika sifat-sifat yang dimiliki “raja” dihilangkan bagian
sifat-sifat “pria”-nya, kemudian ditambahkan sifat-sifat “wanita” maka idealnya
operasi ini menghasilkan vektor yang dekat kaitannya dengan “ratu”. Dengan
kata lain, raja yang tidak maskulin tetapi fenimin disebut ratu. Seperti
yang disebutkan sebelumnya, ini adalah tujuan utama _embedding_ yaitu merepresentasikan
“makna” kata sebagai vektor sehingga kita dapat memanipulasi
banyak hal berdasarkan operasi vektor. Hal ini mirip (tetapi tidak sama)

(^12) source: Pinterest

```
12.5 Representing Context: Word Embedding 175
```
dengan prinsip _singular value decomposition_ dan _autoencoder_ yang telah dijelaskan
sebelumnya.

```
Gambar 12.7: Contoh operasi vektor kata.
```
Selain _vector space model_, apakah ada cara lain yang mampu merepresentasikan
kata dengan lebih baik? Salah satu kekurangan VSM adalah
tidak memadukan sifat sekuensial pada konstruksi vektornya. Cara lebih baik
d _item_ ukan oleh [48, 49] dengan ekstensi pada [70]. Idenya adalah menggunakan
teknik _representation learning_ dan prinsip _statistical semantics hypothesis_.
Metode ini lebih dikenal dengan sebutan _word_ 2 vec. Tujuan _word_ 2 vec
masih sama, yaitu merepresentasikan kata sebagai vektor, sehingga kita dapat
melakukan operasi matematis terhadap kata. _Encoder_ -nya berbentukContinous
bag of words(CBOW)atauSkip-gram. Pada CBOW, kita memprediksi
kata diberikan suatu “konteks”. Pada arsitektur ”Skip-gram” kita
memprediksi konteks, diberikan suatu kata. Ilustrasi dapat dilihat pada Gambar
12.8. Bagian _projection layer_ pada Gambar 12.8 adalah _coding_ layer. Kami
akan memberikan contoh CBOW secara lebih detil. Kedua arsitektur ini dapat
dilatih menggunakan _one-hot encoding_, i.e.,wimerepresentasikanone-hot
_encoding_ untuk kata ke-i.
Perhatikan Gambar 12.9. Diberikan sebuah konteks “si kucing duduk ...
tiker”. Kita harus menebak apa kata pada “...” tersebut. Dengan menggunakan
teknik _autoencoder_, _output layer_ adalah distribusi probabili _task_ atai
pada konteks tersebut. Kata yang menjadi jawaban adalah kata dengan probabilitas
terbesar, misalkan pada kasus ini adalah “beralaskan”. Dengan arsitektur
ini, prinsip sekuensial atau _time series_ dan _statistical semantics hypothesis_
terpenuhi ( _to a certain extent_ ). Teknik ini adalah salah satu contoh penggunaan _neural_
_network_ untuk _unsupervised learning_. Kita tidak perlu mengkorespondensikan
kata dan _output_ yang sesuai karena _input vektor_ didapat dari
statistik penggunaan kata. Agar lebih tahu kegunaan vektor kata, kamu dapat
mencoba kode dengan bahasa pemrograman Python 2.7 yang disediakan
penulis.^13 Buku ini telah menjelaskan ide konseptual _word embedding_ pada

(^13) https://github.com/wiragotama/GloVe_Playground

176 12 Auto _encoder_

```
𝑤!"#
```
```
𝑤!$%
```
```
𝑤!"%
```
```
𝑤!$#
```
```
𝑤!
```
```
Weighted
Sum
```
```
INPUT OUTPUT
```
```
𝑤!
```
```
𝑤!"#
```
```
𝑤!$%
```
```
𝑤!"%
```
```
𝑤!$#
```
```
Projection
(Representation)
```
```
INPUT OUTPUT
```


### 9.3 Feature Selection

Pada pembelajaran mesin, pada umumnya kita menggunakan banyak (lebih
dari satu) fitur. Artinya kita merepresentasikan setiap _record_ ( _instance_ ) atau
_inputs_ ebagai suatu vektorx∈R^1 ×F; dimanaFmelambangkan dimensi vektor
atau banyaknya fitur. Seringkali,F bernilai besar sehingga model yang
kita miliki kompleks. Kita tentunya ingin mengurangi kompleksitas dengan

(^1) Curse of Dimensionality

```
9.3 Feature Selection 119
```
alasan-alasan yang sudah disebutkan pada subbab 9.2. Alasan lainnya karena
belum tentu semua fitur berguna. Cara termudah adalah dengan menghapus
fitur yang memiliki nilai varians = 0. Sayang sekali, hal ini tidak selalu terjadi.
Subbab ini membahas teknik-teknik yang dapat digunakan untuk menyederhanakan
fitur (mengurangi dimensi input).

9.3.1 Subset Selection (Feature Ablation)

Cara paling intuitif untuk mencari tahu kombinasi fitur terbaik adalah dengan
mencoba seluruh kombinasi fitur. Misal kita mempunyai fitur sebanyakF, kita
bisa pilih untuk menggunakan atau tidak menggunakan masing-masing fitur,
menghasilkan kombinasi sebanyak 2F. Dari keseluruhan kombinasi tersebut,
kita pilih suatu kombinasi fitur yang memerikan kinerja terbaik. Akan tetapi,
metode _brute force_ ini terlalu memakan waktu. Kita dapat juga menggunakan
teknik _greedy_ yaitu _forward selection_ dan _backward selection_.Forwarddan
_backward selection_ sering juga disebut sebagai _feature ablation_.
Pada _forward selection_, kita mulai dengan suatu model yang tidak menggunakan
fitur apapun sama sekali, yaitu meng- _assign_ kelas yang paling sering
muncul di dataset, pada _input_. Setelah itu, kita tambahkan satu per satu fitur
pada setiap langkah. Langkah berikutnya, kita gunakan satu fitur. DiantaraF
pilihan fitur, kita cari fitur yang memberi nilai terbaik. Kemudian, pada tahap
berikutnya, kita kombinasikan fitur yang kita pilih pada langkah sebelumnya
dengan fitur yang tersisa. Hal ini terus diulang sampai kita sudah menggunakan
seluruh fitur pada model kita. Untuk mencari model terbaik, kita hanya
perlu mencari kombinasi fitur yang memberikan nilai kinerja terbaik.Forward
selectiondiilustrasikan pada Gambar 9.1. Dibanding _brute force_ yang bersifat
eksponensial, _forward selection_ membentuk suatu deret aritmatika kombinasi
fitur yang dicoba, yaituF+ (F−1) +···+ 1 =F(F+ 1)/2. Apabila kita
memiliki fitur sebanyakF = 10, kombinasi _brute force_ menghasilkan 1, 024
kombinasi, sementara _forward selection_ hanya sebanyak 45.

```
Gambar 9.1: Ilustrasi _forward selection_ untuk tiga fitur.
```
_Backward selection_ adalah kebalikan dari _forward selection_. Apabila pada
_forward selection_, kita menambahkan satu fitur tiap langkah, _backward_ selec-

120 9 Seleksi Fitur dan Metode Evaluasi

tionmengurangi satu fitur pada tiap langkah. Ilustrasi diberikan pada Gambar
9.2. Seperti _forward selection_, _backward selection_ juga hanya mencoba sebanyakF(F+
1)/2 kombinasi. Kita juga dapat menggabungkan _forward_ dan
_backward selection_ menjadi metode _hybrid_, yaitu menambah satu fitur pada
tiap langkah, serta memperbolehkan untuk menghilangkan fitur juga [20].

```
Gambar 9.2: Ilustrasi _backward selection_ untuk tiga fitur.
```
9.3.2 Shrinkage

Ingat kembali materi bab 5 tentang _regularization_. Seperti yang sudah dijelaskan,
kita ingin agar model kita sesederhana mungkin. Mengurangi dimensi
fitur adalah cara mengurangi kompleksitas. Ingat kembali, dengan menggunakan
suatu fungsi regularisasi, objektif pembelajaran adalah meminimalkan
_loss_ dan kompleksitas, seperti pada persamaan 9.1. Kompleksitas model dapat
dihitung menggunakanL 2 (Ridge, persamaan 9.2) atauL 1 (Lasso, persamaan
9.3) norm. Karena kita ingin meminimalkan norm, artinya kita juga
membuat parameter model pembelajaran mesin bernilai dekat dengan nol.
Pada metode Ridge, kita ingin meminimalkan fungsi eksponensial, sementara
fungsi skalar pada Lasso. Artinya, Lasso lebih cenderung untuk menghasilkan
suatu model yang bersifat _sparse_. Dengan kata lain, Lasso melakukansubset
_feature selection_ seperti yang sudah dijelaskan pada subbab sebelumnya.
Sementara itu, Ridge cenderung tidak meng-nol-kan parameter, melainkan
hanyadekatdengan nol [20]. Kamu mungkin berpikir, kenapa kita tidak
menggunakan Lasso saja, berhubung ia mengeleminasi fitur. Pada metode
Ridge, semua fitur tetap digunakan walaupun nilainya diturunkan ( _shrink_ )
agar dekat dengan nol. Hal ini, walaupun tidak mengeleminasi fitur, dapat
mengurangi variasi kinerja model.^2 (dijelaskan pada subbab 9.5)

```
wˆ= arg min
w
```
```
L(w) +λR(w) (9.1)
```
```
R(w) =‖w‖^22 =
```
#### ∑

```
i
```
```
(wi)^2 (9.2)
```
(^2) baca buku [20] untuk pembuktiannya

```
9.3 Feature Selection 121
```
```
R(w) =‖w‖=
```
#### ∑

```
i
```
```
|wi| (9.3)
```
Secara singkat, Ridge digunakan untuk menghasilkan model yang varian
kinerjanya kecil. Sementara itu, Lasso digunakan untuk menghasilkan model
yang mudah dimengerti ( _interpretability_ ) dengan mengeliminasi fitur.

9.3.3 Principal Components Analysis (Dimensionality Reduction)

Teknik-teknik sebelumnya berfokus pada cara mengeleminasi fitur. Akan
tetapi, penghapusan suatu fitur berpotensi pada model yang tidak mampu
mengerti kompleksitas permasalahan. Dengan kata lain, _oversimplification_.
Dibanding menghapus fitur, cara lain untuk mengurangi kompleksitas komputasi
adalah mentransformasi data ke dalam dimensi lebih kecil. Untuk _input_
yang memilikiFfitur, kita kurangi dimensi _input_ menjadiM < F(dimensionality
reduction). Apabila kita mampu mengurangi dimensi _input_, maka kita
juga dapat mengurangi jumlah parameter pada model pembelajaran mesin,
yang artinya mengurangi kompleksitas komputasi dan meningkatkaninter-
pretability.
Ide utama _dimensionality reduction_ adalah mentransformasi data dari suatu _space_ ke _space_
lainnya, dimana data direpresentasikan dengan dimensi
lebih kecil. Dengan catatan, data dengan dimensi lebih kecil harus mampu
merepresentasikan karakteristik data pada dimensi aslinya! Dengan demikian,
satu fitur pada dimensi yang baru mungkin memuat informasi beberapa fitur
pada dimensi aslinya. Walaupun model yang kita hasilkan lebih sederhana
secara jumlah parameter, tetapi kita membutuhkan usaha ekstra untuk
mengerti representasi fitur-fitur pada dimensi yang baru.
Teknik yang digunakan untuk mengurangi dimensi adalahprincipal component
analysis. Ide dasarnya adalah mencari bentuk data (pada dimensi
lebih kecil) yang memiliki nilai varians tinggi untuk tiap fiturnya, karena
varians yang tinggi berarti kemampuan fitur yang tinggi dalam melakukan
diskriminasi (klasifikasi). Kita ingin mencari suatu arah ( _vektor_, matriks, tensor)
dimana data kita memiliki varians tertinggi. Pada dimensi yang baru,
kita berharap data kita tersebar menjadi beberapa kelompok yang mudah
dibedakan ( _easily separable_ ). Arah ini dikenal sebagaieigenvector, dan nilai
varians pada arah tersebut dikenal sebagaieigenvalue. Kami harap kamu
ingat materi kuliah aljabar linear. Eigenvector yang memiliki nilai eigenvalue
tertinggi disebut sebagai _principal components_, yaitu semacam bentuk
_data_  yang ringkas. Selain mengurangi dimensi, teknik ini juga mengurangi
(atau meniadakan) interaksi antar-fitur. Dengan demikian, kita dapat menggunakanadditive
assumptionsaat melakukan pembelajaran (ingat kembali
materi bab 5).
Saat melakukan analisis ini, kita membuat suatu asumsi bahwa sejumlah
_principal components_ cukup untuk merepresentasikan variasi yang ada pada
_data_  [20]. Dengan kata lain, kita mengasumsikan arah (eigenvector) ketika

122 9 Seleksi Fitur dan Metode Evaluasi

_data_  memiliki varians tertinggi, adalah arah yang berasosiasi dengan _output_.
_Singular Value Decomposition_ adalah salah satu teknik untuk melakukanprincipal
component analysis. Hal tersebut akan dibahas pada bab 12. Buku ini
juga akan memberi contoh konkret _dimensionality reduction_ denganartificial
_neural network_ pada bab 12.


### 9.6 Replicability, Overclaiming dan Domain Dependence

Pada dunia pembelajaran mesin, _replicability_ adalah hal yang sangat penting.
Artinya, eksperimen yang kamu lakukan dapat diulangi kembali oleh orang
lain, serta mendapat kinerja yang kurang lebih sama. Untuk ini, biasanya
_dataset_  dipublikasi pada domain publik agar dapat digunakan oleh banyak
orang, atau mempublikasi kode program. Selain _replicability_, kamu juga harus
memperhatikan _overclaiming_. Banyak orang yang menggunakan _toy dataset_
(berukuran sangat kecil) yang tidak merepresentasikan permasalahan aslinya.
Akan tetapi, mereka mengklaim bahwa model mereka memiliki generalisasi
yang baik. Kamu harus menginterpretasikan kinerja model secara bijaksana.
Kinerja yang baik pada _toy dataset_ belum tentu berarti kinerja yang baik
pada dunia nyata. Sebagai contoh, artikel yang dibahas pada _post_ ^4 ini adalah
contoh _overclaiming_.
Perlu kamu perhatikan juga, mendapatkan kinerja yang bagus pada suatu
_dataset_  belum tentu berarti model yang sama dapat mencapai kinerja yang
baik pada dataset lainnya. Misalnya, model yang dilatih untuk mengklasifikasikan
kategori berita belum tentu dapat mengklasifikasikan laporan medis.
Hal ini banyak terjadi pada _supervised learning_ [40]. Selain itu, kamu harus
memperhatikan karakteristik _performance metric_ yang digunakan agar tidak
salah menginterpretasikan kualitas model.


### 9.1 Feature Engineering

Record ( _data_ ) pada pembelajaran mesin pada umumnya dikonversi menjadi
suatu vektor ( _feature vector_ ) yang merepresentasikannya dalam bentuk
matematis. Fitur-fitur biasanya tersusun atas atribut yang kita anggap
memiliki pengaruh terhadap _output_. Sebagai contoh, tekanan darah diprediksi
berdasarkan usia, jenis kelamin dan BMI. Seringkali, seseorang membutuhkan
keahlian suatu bidang agar dapat memilih fitur yang tepat. Proses untuk
mencari (atau me-list) kandidat fitur, disebut sebagai aktivitasfeature en-
gineering.
Seperti kata mutiara yang kami berikan pada awal bab ini, kunci pembelajaran
mesin adalah representasi permasalahan. Fitur yang dipilih untuk
merepresentasikan data adalah bagaimana cara kamu merepresentasikan
masalah juga. Karena membutuhkan tingkat keahlian tertentu, proses memilih
fitur tidaklah mudah. Bisa jadi (sering), orang memilih fitur yang tidak representatif!
Dengan demikian, tidak heran apabila seseorang mempublikasikan
makalah ilmiah atas kontribusinya menentukan fitur baru pada domain ter-
tentu.

118 9 Seleksi Fitur dan Metode Evaluasi

Konon tetapi, proses pemilihan fitur yang bersifat manual ini cukup bahaya
karena rentan dengan _bias_, yaitu kemampuan seseorang pada domain
tertentu. Alangkah baiknya, apabila kita dapat memilih fitur yang memang
benar-benar diperlukan (murni) secara otomatis. Hal tersebut akan dibahas
lebih lanjut pada materi _artificial neural network_. Hal ini salah satu alasan
yang membuatnya populer.


### Soal Latihan

9.1. Seleksi Fitur
Jelaskanlah algoritma seleksi fitur selain yang sudah dijelaskan pada bab ini!
(Saran: baca _survey paper_ )

(^4) Pranala Post Yoav Goldberg

```
9.6 Replicability, Overclaiming dan Domain Dependence 133
```
9.2. AIC dan BIC
Jelaskan _Akaike Information Criterion_ (AIC) danBayesian Information Cri-
terion(BIC)!

9.3. AUC
Jelaskan _Area Under Curve_ (AUC)!

9.4. Dependency Parsing
Salah satu permasalahan penting pada bidang pemrosesan bahasa alami
adalah _dependency parsing_, dimana kita ingin memprediksi hubungan antar
kata pada suatu kalimat. Permasalahan ini sangatlah baik untuk mengilustrasikan
_model_  yang memprediksi _output_ berupa graph. Bacalah paper oleh
Kipperwasser dan Goldberg [39] tentang cara mereka me _model_ kan persoalan
tersebut dan jelaskan pada temanmu. Apakah evaluasi yang mereka lakukan
sudah cukup?

9.5. Bootstrapping
Jelaskan apa itu teknik _bootstrapping_ (evaluasi model)! Bagaimana perbedaanya _bootstrapping_ dancross
_validation_ ?

9.6. Varians
Jelaskan mengapa fitur yang baik memiliki varians yang tinggi, sementara
kinerja model yang baik memiliki varians yang rendah!


### 9.5 Cross Validation

Ingat kembali materi bab-bab sebelumnya bahwa pada umumnya kita membagi
_dataset_  menjadi tiga kelompok: _training_, _validation/development_ dan

130 9 Seleksi Fitur dan Metode Evaluasi

_testing_. Melatih dan mengukur kinerja model menggunakan training data
adalah hal yang tidak bijaksana karena kita tidak dapat mengetahui kemampuan
generalisasi model. Kita melatih model pembelajaran mesin menggunakan _training_
_data_ yang dievaluasi kinerjanya (saattraning) menggunakan
_validation data_. Setelah itu, kita uji model kembali menggunakan _testing data_.
Pada umumnya, ketiga kelompok tersebut memiliki data dengan karakteristik
yang sama. Artinya, dataset disampel dari distribusi yang sama. Misal pada
_training data_, ada pembagian 30:30:40 untuk data kelas pertama, kedua dan
ketiga. Distribusi persebaran tersebut juga harus sama pada _validation_ dan
_testing data_. Hal penting yang harus diperhatikan adalah tidak boleh ada data
yang sama ( _overlap_ ) pada ketiga kelompok tersebut.

Gambar 9.7: Model yang stabil (a) memberikan _decision boundary_ (garis hitam)
yang serupa walaupun _inputs_ edikit diubah-ubah (variasi kinerja yang
kecil, untuk set _input_ yang berbeda). Model yang kurang stabil (b) memberikandecision
boundary yang berbeda untuk _input_ yang sedikit diubahubah
(variasi kinerja yang besar, untuk set _input_ yang berbeda).

Pada dunia nyata, kita belum tentu memiliki ketiga kelompok tersebut.
Penyebabnya ada banyak, misal dataset yang kecil (hanya memiliki sedikit
_records_ ) atau pengadaan _testing data_ mahal. Apabila kita tidak memiliki _testing_
_data_, _validation data_ dapat menjadi pengganti ( _proxy_ ).
Akan tetapi, permasalahan _statistical bias_ dapat terjadi apabila kita hanya
menguji model pada satu set data karena kita tidak mengetahui variasi kinerja
_model_  [20]. Sebisanya, kita ingin mengevaluasi kinerja model pada beberapa
_dataset_, dan mengevaluasi variasi kinerja model. Kegiatan semacam
ini membuat kita mengetahui apakah suatu model cukup stabil^3 dan fleksi-

(^3) https://en.wikipedia.org/wiki/Stability_( _learning_ _theory)

```
9.5 Cross Validation 131
```
bel. Stabil berarti kinerja model tidak begitu berubah, diberikan _input_ yang
sedikit berubah (ilustrasi diberikan pada Gambar 9.7). Fleksibel berarti model
yang mampu menangkap karakteristik data dengan baik. Misal kita menggunakan
_model linear_  dengan persamaan polinomial orde-1, orde-2 dan orde-3.
Saat kita menaikkan orde persamaan sampai dengan orde-3, kinerja model
terus meningkat pada _validation_ data, walaupun kurang lebih sama pada
_training data_. Lalu, kita mencoba menggunakan persamaan polinomial orde-4,
dan kinerja model menurun pada _validation_ data. Artinya, persamaan polinomial
orde-3 adalah yang paling optimal untuk me _model_ kan permasalahan
yang kita miliki. Apabila kita tidak memiliki _validation_ data, kita tidak akan
mengetahui hal ini. Stabil berkaitan dengan nilai varians, sedangkan fleksibel
berkaitan dengan perubahan terhadap ukuran kinerja. Fleksibilitas dapat
dianalisis dengan mem- _plot_ grafik kinerja model pada _training data_ dan _validation_ / _testing_
_data_  untuk mengetahui _underfitting_ dan _overfitting_ seperti
yang sudah dijelaskan pada bab 5.

```
1 2 3 ... N
```
```
Fold 1
```
```
Fold 2
```
```
Fold 3
Fold 4
```
```
Fold 5
```
```
_Training_  data Validation data
```
Gambar 9.8: Ilustrasi 5- _fold-cross-validation_. Kotak berwarna merah melambangkan
subset yang dipilih sebagai _validation data_.

Kita dapat menganalisis stabilitas dengan menggunakan teknik cross
_validation_ seperti yang sudah dijelaskan pada bab 3. Intinya adalah, kita
membagi-bagi _dataset_ yang kita miliki menjadiKbagian. Kita latih model
menggunakanK−1 bagian, kemudian menguji prediksi model pada satu
bagian lainnya (sebagai _validation data_ ) yang mengaproksimasi kinerja pada
_testing data_ (Ilustrasi pada Gambar 9.8). Perhatikan, walau disebut _validation_
_data_, group ini digunakan sebagai _testing data_ pada saat proses latihan.
Perlu diperhatikan, distribusi tiap-tiap kelas pada subset data haruslah sama
( _stratified sampling_ ).
Prosedur ini disebut sebagaiK- _fold-cross-validation_. Untuk K=N;
N=jumlah data, disebut sebagai leave-one-out-cross- _validation_. Den-

132 9 Seleksi Fitur dan Metode Evaluasi

gan teknik _cross validation_, kita memiliki sejumlahK model pembelajaran
mesin danKbuah nilai kinerja. Kita dapat mengukur stabilitas model dengan
menghitung varians kinerja dariK model. Nilai rata-rata kinerja yang
diberikan adalah sebuah estimasi terhadap kinerja model pada _testing data_
(yang sesungguhnya tidak ada), diberikan pada persamaan 9.11. Kita ingin
_model_  yang stabil, karena nilai varians yang kecil berarti eksperimen dapat
diulangi, dan kita mendapatkan kinerja yang sama saat eksperimen diulang.
Varians yang terlalu besar dapat berarti kita mendapatkan suatu nilai kinerja
secara _random chance_ (untung-untungan belaka).

```
Performa =
```
#### 1

#### K

#### ∑K

```
i=1
```
```
KinerjaModeli (9.11)
```


### 9.4 Evaluasi Kinerja Model

Buku ini telah menjelaskan bahwa model pembelajaran mesin mengoptimisasi
_utility function_ pada saat proses latihan ( _training_ ). Pada umumnya,utility
_function_ berbentuk _cross entropy_ atau _error function_ untuk arsitekturlinear
_model_ dan _neural network_. Untuk arsitektur lain, seperti _support vector_
machine, kita mencari _support vectors_ yang memberikan _margin_ (decision
boundary) terbaik untuk memisahkan dua kelas. Model _decision tree_ dibangun
berdasarkan _information gain_ tiap atribut data. Sementara, modelHidden
Markov Modelmengoptimalkan _forward_ dan _backward probability_. Kegiatan
evaluasi model tidak berhenti saat _training_ telah mencapai nilai _utility function_ yang
optimal, tetapi kita juga mengevaluasi kinerja model pada _validation_
_data_ (baik mengukur _utility function_ dan _performance measure_ ). Terakhir,
kita juga mengevaluasi prediksi model dengan mengukurperformance
measurepada _test data_. Subbab ini akan menjabarkan beberapa contohperformance
measureuntuk mengevaluasi hasil prediksi model pada kasus _supervised_
_learning_.

```
Kelas A Kelas B Kelas C Kelas D
0.2 0.6 0.1 0.1
```
Tabel 9.1: Contoh _class-assignment probability_ pada _multi-class classification_.

Ingat kembali persoalan _multi-class classification_. Tujuan suatu model
pembelajaran mesin adalah mengoptimalkan class- _assignment_ probability,
yaitu probabilitas masing-masing kelas untuk suatu ( _given_ ) _input_ (Tabel 9.1).
Dengan meminimalkan _cross-entropy_ saat proses latihan, kita harap model
bisa memberikan nilai probabilitas yang tinggi untuk kelas yang tepat, dan
nilai yang rendah untuk kelas lainnya ( _high confidence_ ). Namun, urusan evaluasi
_model_  tidak hanya sampai di titik ini saja. _Class-assignment probability_ berikutnya
dikonversi menjadi keputusan final, yaitu memilihsatukelas
mana yang tepat untuk _input_ yang diberikan. Dengan kata lain, kita harus
mengevaluasi penerjemahan “raw” _class-assignment probability_ menjadi sebuah
prediksi final. Pada kasus Tabel 9.1, _output_ atau prediksi final dari
_model_  bersangkutan adalah “Kelas B”.

```
9.4 Evaluasi Kinerja Model 123
```
Sebagai contoh lain, _support vector classifier_ memberikan skor +1 atau
−1 untuk _input_. Skor tersebut berkorespondensi dengan kelas A atau kelas B.
_Output_ final model pun adalah kelas yang tepat untuk _input_ yang diberikan.
Hal yang serupa terjadi pada _Naive Bayes_, _Linear Model_, _Decision Tree_ dan
_supervised learning model_ lain yang dijelaskan pada buku ini ( _term_ asuk _neural_
_network_ ). Walaupun model- _model_ tersebut mengoptimasi _utility function_
atau dikonstruksi dengan cara yang berbeda, prediksi final _multi-class_ _classification_
adalah kelas yang sesuai untuk _input_. Subbab ini membahas cara
mengevaluasi keputusan prediksi final model.

9.4.1 Akurasi

Akurasi adalah _performance measure_ paling sederhana dan sering digunakan
saat mengevaluasi kinerja model. Akurasi didefinisikan sebagai proporsi prediksi
yang benar dibagi dengan banyaknya sampel. Diberikan _desired output_ (juga
dikenal dengan “ _gold standard_ ”)ydan hasil prediksiˆy, kita menghitung proporsi
banyaknya elemen yang sama antaraydanˆy. Secara matematis, akurasi
diformulasikan pada persamaan 9.4, dimanaNmerepresentasikan banyaknya
sampel.

```
Akurasi =
```
#### 1

#### N

#### ∑N

```
i=1
```
```
verdicti
```
```
verdicti=
```
#### {

```
1 , yi= ˆyi
0 , yi 6 = ˆyi
```
#### (9.4)

Sebagai contoh, suatu model pembelajaran mesin mengklasifikan gambar
buah menjadi “ _apel_ ” dan “jeruk” ( _binary classification_ ). _Desired output_ dan
prediksi model diberikan pada Tabel 9.2. Pada tabel ini, ada lima prediksi
yang sama dengan _desired output_, yaitu pada sampel dengan ID=[1, 2 , 4 , 8 ,9].
Dengan demikian, akurasi model adalah 105 = 0.5.
Perhitungan akurasi sama halnya untuk _multi-class classification_, tetapi
menjadi semakin rumit untuk _multi-label classification_. Ingat, padamultilabel
_classification_, suatu _input_ dapat diklasifikasikan menjadi beberapa kelas.
_Multi-label classification_  dapat dievaluasi dengan dua cara. Pertama,
mengevaluasi kinerja pada masing-masing kelas (seolah-olah kita memiliki
beberapa _binary classifier_ ). Cara kedua adalah mengevaluasi prediksimultilabel
secara sekaligus. Perbedaan kedua metode diilustrasikan pada Gambar
9.3. Saat mengevaluasi secara sekaligus, akurasi dapat dihitung sebagai
proporsi banyaknya _exact-match_ dibagi banyaknya sampel.

9.4.2 F1 Score

Metrik yang tidak kalah pentingnya adalah F1 score. F1 score untuk suatu
kelas F1kdidefinisikan sebagai _harmonic mean_ (persamaan 9.5) antara pre-

124 9 Seleksi Fitur dan Metode Evaluasi

```
InstanceDesired Output Hasil Prediksi
1 Jeruk Jeruk
2 Jeruk Jeruk
3 Jeruk Apel
4 Apel Apel
5 Jeruk Apel
6 Apel Jeruk
7 Jeruk Apel
8 Apel Apel
9 Apel Apel
10 Jeruk Apel
```
```
Tabel 9.2: Contoh hasil prediksi model.
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
...
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
...
```
```
Original
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 1
Berita- 2 0 1 1
Berita- 3 0 0 1
...
```
```
Prediction
```
```
Instance Agama Politik Hiburan
1 1 0
0 0 1
0 1 0
...
```
```
Exact match
Partially correct
Complete incorrect
```
```
Evaluate binary
_classification_  sepa _rate_ ly
```
```
Evaluate multi-label
_classification_  at once
Original Prediction
```
```
Gambar 9.3: Cara mengevaluasi _multi-label classifier_ (Gambar 5.8).
```
sisi (persamaan 9.6) dan recall (persamaan 9.7) kelas tersebut. Perhatikan,
yk (persamaan 9.7) melambangkan desired output untuk kelask dan ˆyk
(persamaan 9.6) adalah prediksi untuk kelask. Perhatikan, presisi dan recall
berbeda dari sisi variabel pembagi. Presisi dibagi oleh banyaknya (‖...‖)
prediksi pada kelask, sementara recall dibagi oleh banyaknya prediksiseharusnya(desired
_output_ ) pada kelask.

```
F1k= 2
```
```
Presisik×Recallk
Presisik+ Recallk
```
#### (9.5)

```
9.4 Evaluasi Kinerja Model 125
```
```
Presisik=
```
```
Jumlah prediksi benar pada kelask
‖ˆyk‖
```
#### (9.6)

```
Recallk=
```
```
Jumlah prediksi benar pada kelask
‖yk‖
```
#### (9.7)

Penjelasan sebelumnya cukup _high-level_, sekarang mari kita masuk ke ilustrasi
nyata pada Tabel 9.2. Untuk memudahkan perhitungan, kita susunconfusion
matrixprediksi terlebih dahulu, seperti diilustrasikan pada Tabel 9.3.
_Confusion matrix_  amatlah berguna untuk analisis data, khususnya saat
menghitung F1 score.

```
Prediksi
_apel_  jeruk ‖yk‖
```
```
Gold _apel_ ^314
jeruk 4 2 6
‖ˆyk‖ 7 3
```
```
Tabel 9.3: _Confusion matrix_ prediksi apel dan jeruk berdasarkan Tabel 9.2.
```
```
Berikut adalah cara membaca _confusion matrix_ pada Tabel 9.3:
```
- Ada 3 sampel yang diprediksi sebagai “ _apel_ ” dengan benar.
- Ada 1 sampel yang seharusnya diprediksi sebagai “ _apel_ ”, tetapi diprediksi
    sebagai “jeruk”.
- Ada 4 sampel yang seharusnya diprediksi sebagai “jeruk”, tetapi diprediksi
    sebagai “ _apel_ ”.
- Ada 2 sampel yang diprediksi sebagai “jeruk” dengan benar.
    Nilai‖ˆyk‖untukk=“ _apel_ ” adalah 7, sementara 3 untukk=“jeruk” (jumlah
nilai pada tiap kolom). Nilai‖yk‖adalah 4 dan 6 untukk=“ _apel_ ” dan
k=“jeruk” (jumlah nilai pada tiap baris). Nilai presisi, recall, dan F1 score
untuk masing-masing kelas diberikan pada Tabel 9.4.

```
Kategori Presisi Recall F1 score
Apel^37 =0. 43 34 =0. 75 200 ..^43 43+0×^0 ..^7575 =0. 55
Jeruk^23 =0. 67 26 =0. 33 200 ..^67 67+0×^0 ..^3333 =0.^44
```
Tabel 9.4: Perhitungan nilai presisi, recall dan F1 score untuk masing-masing
kelas untuk contoh Tabel 9.2.

Untuk mendapatkan nilai F1 secara “umum”, kita merata-ratakan F1 _apel_
dan F1jeruk. Prosedur ini disebut _macro-averaging_, yaitu merata-ratakan

126 9 Seleksi Fitur dan Metode Evaluasi

nilai F1 pada masing-masing kelas. Hasilnya disebut sebagai “macro- _average_ d
F1” atau disingkat “F1-macro”. F1-macro untuk contoh pada Tabel 9.3 adalah
0.49.
Terdapat dua variasi lain, yaitu _weighted-average_ (F1- _weight_ ed) dan
_micro-average_ (F1-micro). Pada F1- _weight_ ed, kita memberikan bobot untuk
masing-masing kelas, berdasarkan banyaknya instance yang seharusnya
diklasifikasikan ke kelas tersebut, i.e., banyaknya _desired output_ untuk
masing-masing kelas. F1- _weight_ ed untuk contoh Tabel 9.4 diberikan pada persamaan
9.8. Variasi ini berbeda dengan F1-macro yang menganggap bobot
masing-masing kelas adalah sama.

```
F1- _weight_ ed =
```
#### 4 × 0 .55 + 6× 0. 44

#### 10

#### = 0. 48 (9.8)

F1-macro dan F1- _weight_ ed memisahkan kinerja untuk masing-masing kelas.
Variasi terakhir, F1-micro, melihat hasil prediksi secara keseluruhan tanpa
pemisahan kinerja untuk masing-masing kelas. Sebagai contoh, nilai presisi
dan recall secara keseluruhan diberikan pada persamaan 9.9 dan 9.10. Pada
kasus ini, banyaknya prediksi sama dengan banyaknya prediksi seharusnya.
Dengan demikian, nilai presisi = recall. F1-micro adalah nilai rata-rata presisi
dan recall secara keseluruhan. Karenanya F1-micro = presisi = recall.
Pada kasus _multi-class classification_, nilai F1-micro sama dengan akurasi.

```
Precision =
```
```
Jumlah prediksi benar
Banyaknya prediksi
```
#### =

#### 5

#### 10

#### (9.9)

```
Recall =
```
```
Jumlah prediksi benar
Banyaknya prediksi seharusnya
```
#### =

#### 5

#### 10

#### (9.10)

Ringkasan variasi F1 score diberikan pada Tabel 9.5. F1-macro memiliki
keunggulan dibanding akurasi (F1-micro) dan F1- _weight_ ed pada kasusim _balanced_
_dataset_. Sebagai contoh, kita memiliki sebuah dataset untuk permasalahan _binary_
_classification_ dimana 90% _input_ ditetapkan sebagai kelas A dan
10% sebagai kelas B. Apabila suatu model pembelajaran mesin memprediksi
seluruh data ke kelas A, maka ia akan mendapatkan akurasi 90%. Pada kasus
ini, sesungguhnya model pembelajaran mesin tidak mempelajari distribusi
_data_  dengan benar. Dalam artian, kamu dapat “tertipu” karena nilai akurasi
yang besar, padahal model tersebut sebenarnya tidak memiliki performa yang
baik. F1- _weight_ ed juga akan memberikan nilai yang cukup baik pada kasus ini.
Apabila kita mengukur kinerja menggunakan F1-macro, maka kinerja model
akan terlihat jauh lebih kecil. Cerita ini juga berkaitan dengan _overclaiming_
(subbab 9.6). Akibat penggunaan atau interpretasi metrik yang kurang tepat,
kita mengasumsikan model yang kita buat sudah memiliki kinerja yang cukup
bagus.

```
9.4 Evaluasi Kinerja Model 127
```
```
Metrik Deskripsi
F1-macro Memisahkan kinerja untuk masing-masing kelas, kemudian merataratakan
nilai kinerja.
F1- _weight_ ed Memisahkan kinerja untuk masing-masing kelas, kemudian merataratakan
nilai kinerja dimana setiap kelas memiliki bobot
berdasarkan banyaknya _desired output_ untuk tiap kelas.
F1-micro Melihat hasil prediksi secara keseluruhan tanpa pemisahan kinerja
untuk masing-masing kelas. Nilai F1-micro sama dengan akurasi
pada _multi-class classification_.
```
```
Tabel 9.5: Penjelasan variasi F1 score.
```
9.4.3 Evaluasi Output Berstruktur

Kasus-kasus yang sudah diceritakan pada subbab ini adalah contoh kasus
sederhana baik pada _binary_, _multi-class_ dan _multi-label classification_.
Diberikan sebuah _input_ (e.g., teks, gambar, vektor, suara), kita ingin memprediksi
satu atau beberapa kelas (dari beberapa opsi) yang sesuai untuk
merepresentasikan _input_. Pada kasus yang disebutkan, hasil prediksi suatu
_instance_ adalah independen dari hasil prediksi untuk _instance_ lainnya.
Sekarang, mari kita melanjutkan cerita ke kasus yang lebih kompleks,
yaitu _output_ berstuktur. Pada kasus ini, diberikan sebuah _input_, _output_ model
adalah sebuah data terstruktur, e.g., sekuens kategori, graf, teks.

Sekuens Kategori

Pada _output_ dengan struktur berupa sekuens kategoriy, suatu elemenyi
pada sekuens bisa saja bergantung pada elemen lainnya, misal pada elemen
sebelumnya. Sebagai contoh, pada persoalan Part-of-Speech (POS) _tagging_
(yang sudah dijelaskan pada buku ini), diberikan _inputs_ ekuens katax, kita
ingin memprediksi kelas katayyang bersesuaian (Gambar 9.4). Pada setiap
iterasii, model memprediksi kelas katayiyang cocok bagi _input_ xi. Tujuan
_model_  adalah memprediksi sekuensypaling optimal. Perhatikan, kelas kata
pada posisii(yi) bisa jadi bergantung pada kelas kata di posisii−1 (yi− 1 ),
seperti yang sudah diceritakan pada buku ini. Artinya, suatu elemen _output_ bergantung
pada elemen _output_ lainnya. Walaupun demikian, kita dapat
mengevaluasi tiap elemen _output_ secara independen. Misal, dengan menghitung
akurasi apakah tiap kelas kata pada prediksi ˆyimemang sesuai dengan
_desired output_ yi.

Graf

Evaluasi menjadi cukup kompleks apabila kita memprediksi _output_ dengan
struktur lebih rumit, misalnya sebuah grafG∈(E,V); dimanaE adalah
kumpulan _edge_ danV adalah kumpulan _vertex_. Hal ini cukup lumrah pada

128 9 Seleksi Fitur dan Metode Evaluasi

```
POS tag Noun Verb Noun
Kata Budi Menendang Bola
```
```
Gambar 9.4: Contoh POS _tagging_ (Gambar 8.4).
```
bidang pemrosesan bahasa alami, sebagai contoh pada permasalahanconstituent
parsing, _dependency parsing_, dan _discourse parsing_ (silakan di eksplorasi
lebih lanjut). Gambar 9.5 memberikan contoh _dependency parsing_.

```
Saya suka apel manis
```
```
subjek objek pengubah
```
Gambar 9.5: Ilustrasi _dependency parsing_, dimana kita mencari hubungan
antar-kata (direpresentasikan oleh _edge_ pada graf). Sebagai contoh, “saya”
adalah subjek dari “suka”; “ _apel_ ” adalah objek dari “suka”; “manis” adalah
kata pengubah “ _apel_ ”.

Kita dapat mengevaluasi suatu prediksi struktur dengan cara memfaktorkan
struktur tersebut menjadi unit lebih kecil, kemudian mengevaluasi performa
_model_  pada satuan unit yang lebih kecil. Kinerja model pada satuan
unit diagregat atau digabungkan menjadi satu skor untuk merepresentasikan
keseluruhan performa dalam memprediksi suatu struktur [39]. Pemilihan unit
atau teknik faktorisasi struktur bergantung pada domain permasalahan. Sebagai
contoh, suatu model X yang mampu memprediksi _edges_ pada graph
dengan cukup akurat ternyata tidak dapat memprediksi suatu jalan ( _path_ )
dari _node_ A ke B yang seharusnya ada pada _desired output_. Dengan demikian,
kamu mungkin ingin memfaktorkan graf tersebut menjadi sekumpulan _paths_.
Hal terpenting saat mengevaluasi structured output prediction adalah
mengevaluasi berbagai aspek dan mempertimbangkan berbagai perspektif.
Artinya, memfaktorkan struktur menjadi beberapa (≥1) macam unit, dari
unit yang “kecil” (e.g., _edge_ ) sampai unit yang “besar” (e.g., _subtree_ pada
struktur pohon; _path_ atau subgraph pada graf). Pemilihan unit pada proses
faktorisasi bergantung pada domain permasalahan.

Teks

Evaluasi menjadi semakin kompleks apabila kita tidak dapat mendefinisikan
metrik secara matematis. Misal pada _image captioning task_ : diberikan sebuah
gambar dan suatu model harus menjelaskan apa isi gambar tersebut (ilustrasi
pada Gambar 9.6). Dari sisi “bentuk” _output_, teks adalah sebuah sekuens
kata. Akan tetapi, setiap kata memiliki maknanya tersendiri. Makna kata

```
9.5 Cross Validation 129
```
dapat berubah pada konteksnya, i.e., ketika beberapa kata membentuk sebuah
klausa atau kalimat. Selain itu, teks memiliki struktur “implisit”. Sebagai
contoh, kata-kata pada teks harus membentuk suatu kesatuan makna sebagai
kalimat. Tiap kalimat juga harus sesuai dengan aturan tata bahasa. Hal ini
membuat teks menjadi lebih rumit (dan unik) dibanding sekuens kategori.

```
Image
```
```
Model
"Seseorangsedangbermain
tenis”
```
```
Caption
```
```
Gambar 9.6: Ilustrasi _image captioning task_.
```
Pada kasus _image captioning task_ seperti diatas, bagaimana cara kamu
mengevaluasi apakah model mampu memberikan penjelasan yang merefleksikan
situasi pada gambar? Sebagai contoh, apabila diberikan gambar “seseorang
sedang bermain tenis”, dan model memprediksi “seseorang sedang
bermain basket,” maka model memberikan penjelasan yang salah. Tetapi
apabila kamu melihat dari sisi proporsi banyaknya kata yang sama, terdapat
banyak kata pada _desired output_ yang beririsan dengan prediksi, yaitu
“seseorang sedang bermain.”
Hal serupa juga harus diperhatikan pada persoalan mesin translasi bahasa.
Apakah konten translasi memang benar sama dengan konten aslinya?
Bagaimana dengan gaya penulisan? Pada sistem peringkasan teks, apakah
hasil ringkasan memang benar sesuai dengan teks aslinya, bukan menambah
informasi atau mengada-ada?
Cerita pada subbab 9.4 mengilustrasikan bahwa evaluasi model adalah
perkara yang kompleks. Pemilihan metrik yang salah dapat mengakibatkan
kamu menganggap bahwa model sudah “cukup” baik, padahal model tersebut
memberikan banyak prediksi yang salah. Subbab ini juga sekilas menjelaskan
bahwa bentuk _output_ pada _supervised learning_ bisa saja memiliki struktur
yang rumit.


### 9.2 High Dimensional Data

Pada kenyataan, fitur yang kita gunakan untuk membangun model pembelajaran
mesin tidaklah sesederhana yang dicontohkan pada subbab sebelumnya.
Seringkali, kita berhadapan dengan data yang memiliki sangat banyak
fitur ( _high dimensional data_ ). Sebagai contoh, seorang marketing analyst
mungkin saja ingin mengerti pola seseorang berbelanja pada _online shop_.
Untuk mengerti pola tersebut, ia menganalisis seluruh kata kunci pencarian
( _search term_ ) _item_. Misalnya, seseorang yang ingin membeli meja makan
juga mungkin akan membeli kursi (sebagai satu paket). Data pada analisis
semacam ini berdimensi besar. Seberapa besar dimensi yang dapat disebut
_high dimension_ adalah hal yang relatif.
Sayangnya, data dengan dimensi yang sangat besar membawa beberapa
masalah pada pembelajaran mesin. Pertama, model pembelajaran susah untuk
memiliki kinerja yang optimal pada data berdimensi tinggi. Semakin
banyak fitur yang dipakai, semakin kompleks suatu model pembelajaran mesin
harus me _model_ kan permasalahan. Berhubung kita memiliki banyak fitur,
_search space_ untuk mencari konfigurasi parameter optimal sangatlah luas.
Hal ini dapat dianalogikan seperti mencari seseorang pada gedung berlantai
satu vs. gedung berlantai 20. Kedua, hal ini menyebabkan mudah terjadi _overfitting_ karena
ada sangat banyak konfigurasi fitur walaupun kita hanya memiliki
_data_  yang terbatas.^1 Ketiga, data dengan dimensi yang besar susah untuk
diproses secara komputasi ( _computationally expensive_ ), baik dari segi memori
dan waktu. Karenanya hal ini, kita ingin agar fitur-fitur yang kita gunakan
sesedikit mungkin. Dengan kata lain, kita ingin representasi permasalahan
sesederhana mungkin dari sesi memori dan _computational processing_.


### 8.5 Algoritma Viterbi

Pada subbab sebelumnya, telah didefinisikan permasalahan POS _tagging_ dan
_Hidden Markov Model_ untuk menyelesaikan permasalahan tersebut. Pada bab
ini, kamu akan mempelajari cara mencari sekuens _syntactical categories_ terbaik
diberikan suatu observasi kalimat menggunakanalgoritma Viterbi. Hal
ini disebut proses _decoding_ pada HMM. Algoritma Viterbi adalah salah satu
algoritma _dynamic programming_ yang prinsip kerjanya mirip denganminimum
edit distance.^6 Ide utama algoritma Viterbi adalah mengingat sekuens
untuk setiap posisi tertentu (setiap iterasi, setiap panjang kalimat). Apabila
kita telah sampai pada kata terakhir, kita lakukan _backtrace_ untuk mendapatkan
sekuens terbaik.

_function_ VITERBI( _observations_ of lenT, _state-graphs_ of lenS)

```
Initialization Step
create a path of probability matrix viterbi[S,T]
foreach statesfrom 1 toSdo
viterbi[s,1]←a 0 ,s×bs(o 1 )
_backpointer_ [s,1]← 0
```
```
Ite _ratio_ n Step
foreach time steptfrom 2 toTdo
foreach statesfrom 1 toSdo
viterbi[s,t]←arg maxj=1,Sviterbi[j,t−1]×as,j×bs(ot)
_backpointer_ [s,t]←index ofjthat gave the max above
```
```
Sequence Identification Step
cT←ithat maximizes viterbi[i,T]
fori=T− 1 to 1 do
ci← _backpointer_ [ci+1,i+ 1]
```
```
Gambar 8.8: Algoritma Viterbi [12, 38].
```
Perhatikan Gambar 8.8 yang menunjukkan _pseudo-code_ untuk algoritma
Viterbi. Variabelcberarti kelas kata,aadalah _transition probability_, danb
adalah _lexical-generation probability_. Pertama-tama, algoritma tersebut membuat
suatu matriks berukuranSxTdenganSadalah banyaknya _states_ (tidak

(^6) https://en.wikipedia.org/wiki/Edit_distance

112 8 Hidden Markov Model

_term_ asuk _start state_ ) danT( _time_ ) adalah panjang sekuens. Pada setiap iterasi,
kita pindah ke observasi kata lainnya. Gambar 8.9 adalah ilustrasi algoritma
Viterbi untuk kalimat _input_ ( _observed sequence_ ) “ _flies like a flower_ ”
dengan _lexical generation probability_ pada Tabel 8.3 dan _transition probabilities_ pada
Tabel 8.2 (bigram) [38]. Panah berwarna merah melambangkan
_backpointer_ yaitu _state_ mana yang memberikan nilai tertinggi untuk ekspansi
ke _state_ berikutnya. Setelah _iteration step_ selesai, kita lakukan _backtrace_ terhadap _state_ terakhir
yang memiliki nilai probabilitas tertinggi dan mendapat
hasil seperti pada Gambar 8.10. Dengan itu, kita mendapatkan sekuens
“ _flies_ /N like/V a/ART flower/N”.

Gambar 8.9: Ilustrasi algoritma Viterbi per iterasi. Panah berwarna merah
melambangkan _backpointer_ – _state_ mana yang memberikan nilai tertinggi untuk
ekspansi.

```
Gambar 8.10: Viterbi _backtrace_.
```
Apabila kamu hanya ingin mengetahui HMM tanpa variabel yang perlu
dilatih/diestimasi, kamu dapat berhenti membaca sampai subbab ini. Apabila
kamu ingin mengetahui bagaimana HMM dapat mengestimasi parameter,
kamu dapat melanjutkan membaca subbab berikutnya.

```
8.6 Proses Training Hidden Markov Model 113
```


### Soal Latihan

8.1. Data Numerik
Pada bab ini, diberikan contoh aplikasi Hidden Markov Model (HMM) untuk
POS _tagging_, dimana data kata adalah data nominal. Berikan st _rate_ gi penggunaan
HMM untuk data numerik! Misal, pada _automatic speech recognizer_.

8.2. Ekstensi Algoritma Viterbi
Buatlah ekstensi algoritma Viterbi untuk asumsi trigram!

8.3. Maximum Entropy Markov Model

(a) Jelaskan konsep _maximum entropy_ !
(b) Jelaskan _maximum entropy markov model_ !

8.4. Gibbs Sampling

(a) Jelaskan bagaimana Gibbs sampling digunakan pada HMM!
(b) Jelaskan penggunaan variasi/ekstensi Gibbs sampling pada HMM!

8.5. Latent Dirichlet Allocation
Salah satu materi yang berkaitan erat dengan HMM adalahLatent Dirichlet
Allocation(LDA) yang merupakan anggota keluarga _graphical model_. Jelaskan
apa itu LDA serta bagaimana cara kerja LDA!


### 8.1 Probabilistic Reasoning

Pada logika matematika ( _first order logic_ ), ketika kita memiliki premis “bila
hujan, maka ayu terpeleset.” Pada level _first order logic_, apabila “hujan” ter-

(^1) Karena perlu dijelaskan juga cara transformasi sinyal suara menjadi data diskrit.

```
102 8 Hidden Markov Model
```
```
jadi, maka “terpeleset” juga pasti akan terjadi. Tetapi tidak sebaliknya, apabila
kita “terpeleset”, belum tentu “hujan” juga terjadi. Padaprobabilistic
_reasoning_ kita mengkuantifikasi kepastian atau ketidakpastian itu. Apabila
“hujan” terjadi, berapa besar kemungkinan “terpeleset” juga terjadi (dan se-
baliknya).
Perhatikan Gambar 8.1! Gambar ini menerangkan hubungan pengkondisian _events_,
disebut _Bayesian Network_. Panah dari “hujan” ke “terpeleset”
merepresentasikan bahwa “hujan” adalah kondisi yang menyebabkan
“terpeleset” terjadi ( _causality_ ). Pada kerangka _probabilistic reasoning_, kita
berpikir “karena ada yang terpeleset, mungkin ada hujan dan kecelakaan juga
terjadi.” Tetapi, apabila ada cerita lain bahwa jika ada seseorang yang “terpeleset”
dan memang “hujan”; belum tentu “kecelakaan” terjadi.
```
```
Gambar 8.1: Contoh _Bayesian Network_.
```
```
Gambar 8.2: Tipe jaringan kausalitas.
```
```
Berdasarkan hubungan/jaringan kausalitas antara _events_, ada beberapa
kerangka berpikir yang dapat digunakan: _serial_, _diverging_, dan _converging_ [5];
diilustrasikan pada Gambar 8.2. Karakteristik dari masing-masing tipe kausalitas
adalah sebagai berikut [5]:
```
(a) _Serial_. Bila kita mengetahuiAmaka kita bisa mengetahui sesuatu tentang
BdanC. Tetapi apabila kita mengetahuiB, mengetahuiAtidak akan
membantu inferensi kita terhadapC. MengetahuiCakan membuat kita
mengetahui sesuatu tentangAketika kita tidak mengetahuiB. Artinya,
hubungan antaraAdanCdi- _block_ ketikaBdiketahui. Dengan bahasa

```
8.1 Probabilistic Reasoning 103
```
lebih matematis,AdanC bersifatindependen kondisional(conditionally
_independent_ ) ketikaBdiketahui. Perhatikan, disebut _kondisional_
karena independen jika kondisi (mengetahuiB) terpenuhi.
(b) Diverging. Bila kita mengetahuiAmaka kita bisa mengetahui sesuatu
tentangC, dan sebaliknya. Tetapi apabilaBdiketahui, maka hubungan
antaraAdanCmenjadi terputus. Dengan bahasa lebih matematis,Adan
Cindependen kondisional ketikaBdiketahui.
(c) _Converging_. Tanpa mengetahuiB, kita tidak bisa mencari tahu hubungan
antaraAdanC. Dengan bahasa lebih matematis,AdanCdependen
_kondisional_  ketikaBdiketahui.
Dua buah _events_ XdanYdisebut _d-separated_ apabila terdapat sebuah
_intermediate variable_ Zdiantara mereka dan memenuhi kondisi:

1. Koneksi bersifat _serial_ atau _diverging_, danZdiketahui.
2. Koneksi bersifat _converging_ danZtidak diketahui.
3. Bila tidak memenuhi kondisi yang disebutkan, artinya dua buah variabel
    tersebut tidak _d-separated_, disebut sebagai _d-connected_.
Konsep ini penting dipahami untuk mengerti ide dasar _markov assumption_
yang dibahas pada subbab berikutnya.

```
Gambar 8.3: Contoh inferensi.
```
```
Perhatikan Gambar 8.3! Dengan konsep yang sudah dipahami, mari kita
coba lakukan inferensi pada jaringan tersebut. _Joint distribution_ untuk seluruh _event_ diberikan
pada persamaan 8.1.
```
#### P(A,B,C,D,E) =P(D|B)P(E|B)P(B|A,C)P(A)P(C) (8.1)

```
Sekarang, mari kita hanya lihat subgraf{A,B,E}dengan koneksi tipe _serial_.
BilaAdiketahui, maka kita dapat melakukan inferensi terhadapC, seperti
pada persamaan 8.2.
```
```
P(E|A) =P(E|B)P(B|A)P(A) +P(E|¬B)P(¬B|A)P(A) (8.2)
```

104 8 Hidden Markov Model

Tetapi, apabilaAdan Bdiketahui, maka inferensi terhadapEdilakukan
seperti pada persamaan 8.3.

```
P(E|B,A) =P(E|B)P(B) (8.3)
```
Operasi serupa dapat diaplikasikan pada koneksi tipe _converging_ dan _diverging_.
Perhatikan subgraf{A,B,C}dengan tipe koneksi _converging_ pada Gambar
8.3. ApabilaBtidak diketahui, berartiAdanCterpisah (independen).
ApabilaBdanAdiketahui, maka hubunganAdanCdapat dihitung sebagai
persamaan 8.4.

```
P(C|B,A) =P(C|B)P(B|A)P(A) (8.4)
```
Untuk koneksi tipe _diverging_, silahkan coba bagaimana mencari proses inferensinya!
(pekerjaan rumah).


### 8.6 Proses Training Hidden Markov Model

_Hidden Markov Model_  (HMM) adalah salah satu varian _supervised learning_,^7
diberikan sekuens _input_ dan _output_ yang bersesuaian sebagai _training data_.
Pada kasus POS _tagging_, yaitu _input_ -nya adalah sekuens kata dan _output_ -nya
adalah sekuens kelas kata (masing-masing kata/ _token_ berkorespondensi dengan
kelas kata). Saat melatih HMM, kita ingin mengestimasi parameterAdan
byaitu _transition probabilities_ dan _emission probabilities_ /lexical- _generation_
probabilities(ingat kembali definisi HMM secara formal pada subbab 8.4).
Kita melatih HMM dengan menggunakanAlgoritma Forward-Backward
(Baum-Welch Algorithm).
Cara paling sederhana untuk menghitung emission probabilities atau
_transition probabilities_ adalah dengan menghitung kemunculan pada sampel
( _training data_ ). Sebagai contoh, _emission probability_ suatu kata untuk setiap
kelas kata diberikan pada persamaan 8.14, dimanaN melambangkan
banyaknya kemunculan katawiterlepas dari kelasnya.

```
P(wi|ci) =
```
```
count(wi,ci)
∑N
j=1count(wi,cj)
```
#### (8.14)

Akan tetapi, perhitungan tersebut mengasumsikan _context-independent_, artinya
tidak mempedulikan keseluruhan sekuens. Estimasi lebih baik adalah dengan
menghitung seberapa mungkin suatu kategoricipada posisi tertentu (indeks
kata/ _token_ pada kalimat) pada semua kemungkinan sekuens, diberikan inputw
1 ,w 2 ,...,wT. Kami ambil contoh, kata _flies_ sebagai _noun_ pada kalimat
“ _The flies like flowers_ ”, dihitung sebagai penjumlahan seluruh sekuens yang
berakhir dengan _flies_ sebagai _noun_. ProbabilitasP( _flies_ /N|The flies) =
P( _flies_ /N&The flies)
P(The flies).
Agar lebih _precise_, secara formal, kita definisikan terlebih dahulu _forward_
probabilitysebagai 8.15, dimanaαi(t) adalah probabilitas untuk menghasilkan
kataw 1 ,w 2 ,...,wtdenganwtdihasilkan ( _emitted_ ) olehci.

```
αi(t) =P(wt/ci|w 1 ,w 2 ,...,wt) (8.15)
```
_Pseudo-code_ perhitungan kemunculan kelascisebagai kategori pada posisi
tertentu diberikan oleh Gambar 8.11, denganciadalah kelas kata ke-idanwi
adalah kata ke-i,aadalah _transition probability_,badalah _emission probability_,
danSmelambangkan banyaknya _states_.
Sekarang, kita definisikan juga _backward probability_ βi(t), yaitu probabilitas
untuk menghasilkan sekuenswt,...,wTdimulai dari _state_ wt/ci(ci
menghasilkanwt). Hal ini serupa dengan _forward probability_, tetapi _backward_
probabilitydihitung dari posisi ke-tsampai ujung akhir (tkeT). Anda dapat
melihat _pseudo-code_ pada Gambar 8.12, denganaadalah _transition probability_
danbadalah _emission probability_.

(^7) Walaupun ia termasuk _generative model_.tetapi komponen utama yang di _model_ kan
adalahp(y|x)

114 8 Hidden Markov Model

Initialization Step
fori= 1toSdo
αi(t)←bi(o 1 )×a 0 ,i

Comparing the Forward Probabilities
fort= 2toTdo
fori= 1toSdo
αi(t)←

```
∑S
j=1(aji×αj(t−1))×bi(ot)
```
```
Gambar 8.11: Algoritma _forward_ [38].
```
Initialization Step
fori= 1toSdo
βi(T)←P(ci) # as _sign_ ed using a particular classci

Comparing the Backward Probabilities
fort=T− 1 totdo
fori= 1toSdo
βi(t)←

```
∑S
j=1(aji×βi(t+ 1))×bj(oj+1)
```
```
Gambar 8.12: Algoritma _backward_ [38].
```
Gabungan _forward_ dan _backward probability_ dapat digunakan untuk mengestimasiγj(t)
yaitu probabilitas berada pada _state_ cjpada waktu ke-tdengan
persamaan 8.16.

```
γj(t) =
αi(t)×βi(t)
∑S
j=1αj(t)×βj(t)
```
#### (8.16)

Kita mengestimasi probabilitas keberadaan pada _state_ tertentu, berdasarkan
pengaruh probabilitas keseluruhan sekuens.
Dengan menggunakan _forward probability_ dan _backward probability_ sekaligus,
kita definisikanξt(i,j) yaitu probabilitas berada di _state-i_ pada waktu
ketdan _state_ -jpada waktu ke-(t+ 1) dengan persamaan 8.17.

```
ξt(i,j) =
αi(t)×aij×bj(ot+1)×βj(t+ 1))
αS(T)
```
#### (8.17)

Denganaijadalah _transition probability_ danbj(ot+1) adalah _emission probability_ (ingat
kembali definisi formal HMM pada subbab 8.4). Pada setiap iterasi,
kita ingin memperbaharui kembali parameter HMM yaituAdanb. Kita
hitung kembali _transition probability_ (nilai yang lama di- _update_ ), diberikan
oleh persamaan 8.18.

```
8.6 Proses Training Hidden Markov Model 115
```
```
aij′=
```
#### ∑T− 1

```
∑ t=1 ξt(i,j)
T− 1
t=1
```
#### ∑S

```
j=1ξt(i,j)
```
#### (8.18)

Kita juga menghitung kembali _emission probability_ (nilai yang lama di _update_ ),
diberikan oleh persamaan 8.19.

```
bj(ok)′=
```
#### ∑T

```
t=1,ok=wkγj(t)
∑T
t=1γj(t)
```
#### (8.19)

#### ∑T

```
t=1,ok=wkberarti jumlah observasiwkpada waktut.
```
Initialize A and b
Ite _rate_ until convergence
E-step
γj(t) =∑Sαi(t)×βi(t)
j=1αj(t)×βj(t)

```
ξt(i,j) =
αi(t)×aij×bj(ot+1)×βj(t+1))
αS(T)
```
```
M-step
_update_ aij′=
```
```
∑T− 1
∑T− 1 t=1ξt(i,j)
t=1
```
```
∑S
j=1ξt(i,j)
```
```
_update_ bj(ok)′=
```
```
∑T
t=1∑,ok=wkγj(t)
Tt=1γj(t)
```
```
Gambar 8.13: Algoritma _forward-backward_ (EM) [12].
```
Keseluruhan proses ini adalah cara melatih HMM dengan menggunakan
kerangka berpikir _Expectation Maximization_ : terdiri dariE-stepdanMstep[12].
Pada E-step, kita mengestimasi probabilitas berada di suatu _state_
cjmenggunakanγj(t) dan mengestimasi transisiξt(i,j) berdasarkan parameterAdanbyang
sudah diberikan pada tahap iterasi _training_ ( _epoch_ ) sebelumnya.
Pada M-step, kita menggunakanγdanξuntuk mengestimasi kembali
parameterAdanb. Hal ini dijelaskan secara formal pada Gambar 8.13.
Walaupun HMM menggunakan _independence assumption_, tetapi kita dapat
mengikutsertakanpengaruh probabilitas keseluruhan sekuens untuk
perhitungan probabilitas keberadaan kita pada suatu _state_ ipada
saat ( _time_ t) tertentu. Metode ini dapat dianggap sebagai suatu cara optimalisasi
menggunakan _smoothing_ ^8 terhadap nilai parameter (Adanb). Kita
mencapai titik _local optimal_ apabila tidak ada perubahan parameter.

(^8) https://en.wikipedia.org/wiki/Smoothing

116 8 Hidden Markov Model

Kami ingin mengakui bahwa penjelasan pada subbab 8.6 mungkin kurang
baik (kurang memuaskan). Kami harap kamu mencari referensi lain yang lebih
baik untuk subbab ini.


### 8.2 Generative Model

Pada _supervised learning_ kamu sudah mengetahui bahwa kita me _model_ kan
p(y|x), me _model_ kan _target_ y(label) ketika diberikan _input_ x,^2 yaitu mencari
tahu _decision boundary_ antara keputusan.xdanydapat berupa vektor, skalar,
gambar, dan lain sebagainya. Sementara pada _unsupervised learning_, kita ingin
mengaproksimasi distribusi asli dari sebuah _inputs_ ebagaip(x).
Berbeda dengan keduanya, _generative model_ me _model_ kanp(x,y). Persamaan
itu dapat difaktorkan sebagaip(x,y) =p(y|x)p(x). Pada umumnya,
kita lebih tertarik dengan nilaiyyang menyebabkanp(x,y) bernilai maksimum,
berhubungxakan selalu tetap–karenaxadalah _fixed input_,yterbaiklah
yang ingin kita temukan. Berbeda dengan _supervised learning_, _generative_
_model_ dapat difaktorkan menjadip(y|x) danp(x). Karena berbentukjoint
probability, _generative model_ me _model_ kan peluang kemunculan bersamaan.
Kita ingin mengetahui seberapa mungkin suatu dataxdihasilkan, diberikan
y. Artinya seberapa mungkin _input_ diobservasi untuk suatu _output_. Salah satu
contoh _generative model_ adalah _Hidden Markov Model_ (HMM). HMM me _model_ kan
observasi menggunakan proses _Markovian_ dengan _state_ yang tidak
diketahui secara jelas ( _hidden_ ). Kamu akan mengerti kalimat sebelumnya setelah
membaca penjelasan buku ini seluruhnya.
Ide utama HMM adalah menyelesaikan persoalan _sequence tagging_.
Diberi-kan _input x_ berupa sekuens (sekuens sinyal, sekuens kata, sekuens
gambar, dsb). Kita ingin me _model_ kan sekuens _output_ terbaikyuntuk input
tersebut.^3 Outputke-ibergantung pada _input_ dari awal sampai ke-idan _output_ dari
awal sampai sebelumnyap(yi|y 1 ,...,yi− 1 ,x 1 ,...,xi). Berdasarkan
pemaparan subbab 8.1, apabila suatu _event_ dikondisikan variabel lain dengan

(^2) Parameterwdihilangkan untuk menyederhanakan penjelasan.
(^3) xidanyidapat berupa vektor

```
8.3 Part-of-speech Tagging 105
```
tipe koneksi _serial_, maka kita dapat mengabaikan banyak variabel historis.
Hal ini dituangkan dalam persamaan 8.5,

```
p(yi|y 1 ,...,yi− 1 ,x 1 ,...,xi) =p(yi|yi− 1 ,xi) (8.5)
```
Persamaan ini disebut _first-order markov assumption_, yaitu suatu _event_
yang seharusnya dikondisikan oleh suatu histori hanya bergantung pada
_events_ ebelumnya. Terdapat pula _second_, _third_, dst _markov assumption_ yaitu
bergantung pada dua, tiga, dst _events_ sebelumnya. Walaupun hanya berupa
penyederhanaan, asumsi ini memberi kita banyak keuntungan dari sisi kom-
putasi.


### 8.4 Hidden Markov Model Tagger

Pada subbab sebelumnya, POS _tagging_ telah didefinisikan secara matematis.
Kita sudah mengetahui permasalahan yang ingin kita selesaikan. Subbab ini
adalah formalisasi _hidden markov model tagger_.
Ingat kembali persamaan 8.12 untuk POS tagging.P(wi|ci) disebut _likelihood_ danP(ci|ci−
1 ) disebut _prior_, _multiplication of probabilities_ (

#### ∏

) melambangkanmarkov
chain. _Markov chain_ adalah kasus spesial _weighted automaton_ ^5
yang mana sekuens _input_ menentukan _states_ yang akan dilewati
oleh automaton. Sederhananya, automaton mencapai _goal state_ setelah mengunjungi
berbagai _states_. Total bobot _outgoing edges_ untuk masing-masing
_state_ pada automaton haruslah bernilai satu apabila dijumlahkan. Kasus spesial
yang dimaksud adalah _emission_ (dijelaskan kemudian).
Sebagai contoh, perhatikan Tabel 8.2.ARTadalah _article_,Nadalah _noun_,
V adalah _verb_ danP adalah _preposition_. Mereka adalah contoh kelas kata
yang disederhanakan demi membuat contoh yang mudah. Tabel 8.2 yang
merepresentasikan probabilitas transisi kelas kata, ketika dikonversi menjadi
_weighted automaton_, akan menjadi Gambar 8.5.

```
NULL
```
```
ART V
```
```
N P
```
```
START
```
```
0.71
```
```
0.29
```
```
1
```
```
0.65
```
```
0.43
0.35
```
```
0.26
```
```
0.44
0.13
```
```
0.74
```
```
Gambar 8.5:Weighted automaton[38].
```
(^5) Kami berasumsi kamu sudah mempelajari automata sebelum membaca buku ini.

```
8.4 Hidden Markov Model Tagger 109
```
```
Bigram Estimate
P(ART|null) 0.71
P(N|null) 0.29
P(N|ART) 1
P(V|N) 0.43
P(N|N) 0.13
P(P|N) 0.44
P(N|V) 0.35
P(ART|V) 0.65
P(ART|P) 0.74
P(N|P) 0.26
```
```
Tabel 8.2: Probabilitas bigram [38].
```
Tabel 8.2 dan Gambar 8.5 telah merepresentasikan probabilitas _prior_,
sekarang kita ingin model yang kita punya juga mencakuplexical emission
probabilities, yaitu _likelihood_ pada persamaan 8.12.

```
P(the|ART) 0.54 P(a|ART) 0.360
P( _flies_ |N) 0.025 P(a|N) 0.001
P( _flies_ |V) 0.076 P(flower|N) 0.063
P(like|V) 0.1 P(flower|V) 0.05
P(like|P) 0.068 P(birds|N) 0.076
P(like|N) 0.012
```
Tabel 8.3:Lexical emission probabilities[38]. Tabel ini hanya memuat informasi
yang dibutuhkan untuk ilustrasi cerita (penyederhanaan).

Seumpama kita mempunyai _lexical emission probabilities_ seperti pada
Tabel 8.3. Setiap _state_ pada automaton, dapat menghasilkan/meng- _output_ kan
suatu kata ( _word_ ) dengan probabilitas pada Tabel 8.3. Kita kembangkan
lagi Gambar 8.5 dengan tambahan informasi _lexical emission probabilities_
menjadi Gambar 8.6. Automaton ini disebut _hidden markov model_ (HMM).
Kata _hidden_ berarti, untuk setiap kata pada sekuens, kita tidak mengetahui
kata tersebut dihasilkan oleh _state_ mana secara model (baru diketahui saat
_running_ ). Misalkan, kata _flies_ dapat dihasilkan oleh _state_ N( _noun_ ) atauV
( _verb_ ) [38].
Diberikan kalimat “ _flies like a flower_ ”, untuk menghitung sekuens kelas
kata untuk kalimat tersebut, kita menyelusuri automaton Gambar 8.6. Hasil
penelusuran memberikan kita kombinasi sekuens yang mungkin seperti pada
Gambar 8.7. Pekerjaan berikutnya adalah, dari seluruh kombinasi sekuens
yang mungkin, yaitu

#### ∏T

```
i=1P(wi|ci)P(ci|ci−^1 ). Bagaimana cara kita menen-
```

110 8 Hidden Markov Model

```
NULL
```
```
ART V
```
```
N P
```
```
START
```
```
0.71
```
```
0.29
```
```
1
```
```
0.65
```
```
0.43
0.35
```
```
0.26
```
```
0.44
0.13
```
```
0.74
```
```
P(the|ART)	=	0.54
P(a|ART)	 =	0.360
```
```
P( _flies_ |V) =	0.76
P(flower|V)=	0.05
P(like|V) =	0.1
```
```
P(P( _flies_ |Na|N) ) =	0.25=	0.001 P(like|P) =	0.068
P(flower|N)=	0.063
P(like|N) =	0.012
P(birds|N) =	0.076
```
```
Gambar 8.6: _Hidden Markov Model_.
```
```
Gambar 8.7: Sekuens yang mungkin ( _brute force_ ).
```
tukan sekuens terbaik (paling optimal), yaitu sekuens dengan probabilitas
tertinggi, diberikan pada subbab berikutnya.
Secara formal, _hidden markov model tagger_ didefinisikan oleh beberapa
komponen [12]:

```
1.Q={q 1 ,q 2 ,...,qS}yaitu himpunan _states_ ;Smenunjukkan banyaknya
_states_.
2.A=a 0 , 0 ,a 1 , 1 ,a 2 , 2 ,...,aS,Syaitu _transition probability_ matrixdari
suatu _state_ imenuju _state_ j; dimana
```
#### ∑S

```
j=0ai,j= 1. Indeks 0 merepresentasikanstart
_state_ ( _null state_ ).Smelambangkan banyaknya _states_.
3.o=o 1 ,o 2 ,...,oTyaitu sekuensobservasi(kata/ _input_ );Tadalah panjang
_input_.
4.b=bi(ow) yaitu sekuens dari _observation likelihood_, atau disebut dengan _emission_
probabilities, merepresentasikan sebuah observasi kataow
dihasilkan oleh suatu _state-i_.
```

```
8.5 Algoritma Viterbi 111
```
```
5.q 0 ,qFyaitu kumpulan _states_ pesial yang terdiri dari _start state_ danfinal
_state_ (s).
```


### 8.3 Part-of-speech Tagging

Pada bidang pemrosesan bahasa alami ( _natural language processing_ ), peneliti
tertarik untuk mengetahui kelas kata untuk masing-masing kata di tiap kalimat.
Misalkan kamu diberikan sebuah kalimat “ _Budi menendang bola_ ”. Setelah
proses POS _tagging_, kamu akan mendapat “Budi/Noun menendang/Verb
bola/Noun” (Gambar 8.4). Hal ini sangat berguna pada bidang pemrosesan
bahasa alami, misalkan untuk memilih _noun_ pada kalimat. Kelas kata disebut
sebagai _syntactic categories_. Pada bahasa Inggris, kita mempunyai kelas kata
yang dikenal dengan _Penn Treebank POS Tags_,^4 diberikan pada Tabel 8.1.

```
POS tag Noun Verb Noun
Kata Budi Menendang Bola
```
```
Gambar 8.4: Contoh POS _tagging_.
```
POS _tagging_ adalah salah satu bentuk pekerjaan _sequential classification_.
Diberikan sebuah sekuens kata (membentuk satu kalimat), kita ingin
menentukan kelas setiap kata/ _token_ pada kalimat tersebut. Kita ingin
memilih sekuens kelas kata _syntactic categories_ yang paling cocok untuk katakata/ _tokens_
pada kalimat yang diberikan. Secara formal, diberikan sekuens
kata-kataw 1 ,w 2 ,...,wT, kita ingin mencari sekuens kelas katac 1 ,c 2 ,...,cT
sedemikian sehingga kita memaksimalkan nilai probabilitas 8.6 [12, 38].

```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
```
P(c 1 ,c 2 ,...,cN|w 1 ,w 2 ,...,wT) (8.6)
```
DimanaCadalah daftar kelas kata. Akan tetapi, menghitung persamaan 8.6
sangatlah sulit karena dibutuhkan data yang sangat banyak (kombinasi sekuens

(^4) https://www.ling.upenn.edu/courses/Fall_ _2003/ling001/penn_ _treebank_
pos.html

106 8 Hidden Markov Model

```
No. Tag Description
```
1. CC Coordinating conjunction
2. CD Cardinal number
3. DT De _term_ iner
4. EX Existential there
5. FW Foreign word
6. IN Preposition or subordinating conjunction
7. JJ Adjective
8. JJR Adjective, comparative
9. JJS Adjective, superlative
10. LS List item marker
11. MD Modal
12. NN Noun, singular or mass
13. NNS Noun plural
14. NNP Proper noun singular
15. NNPS Proper noun plural
16. PDT Pre _determiner_
17. POS Possessive ending
18. PRP Personal pro _noun_
19. PRP$ Possessive pro _noun_
20. RB Ad _verb_
21. RBR Ad _verb_, comparative
22. RBS Ad _verb_, superlative
23. RP P _article_
24. SYM Symbol
25. TO to
26. UH Interjection
27. VB Verb base form
28. VBD Verb past tense
29. VBG Verb gerund or present participle
30. VBN Verb past participle
31. VBP Verb non-3rd person singular present
32. VBZ Verb 3rd person singular present
33. WDT Wh- _determiner_
34. WP Wh-pro _noun_
35. WP$ Possessive wh-pro _noun_
36. WRB Wh-ad _verb_

```
Tabel 8.1: Penn Treebank POS Tag.
```
kata sangat sulit untuk didaftar/sangat banyak). Teori Bayes digunakan untuk
melakukan aproksimasi permasalahan ini. Ingat kembali teori Bayes seperti
pada persamaan 8.7.

```
P(x|y) =
P(y|x)P(x)
P(y)
```
#### (8.7)

```
8.3 Part-of-speech Tagging 107
```
Dengan menggunakan teori Bayes, kita dapat mentransformasi persamaan 8.6
menjadi persamaan 8.8.

cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC

```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)P(c 1 ,c 2 ,...,cT)
P(w 1 ,w 2 ,...,wT)
(8.8)
```
Untuk suatu sekuens input,P(w 1 ,w 2 ,...,wT) ( _language model_ ) akan selalu
sama sehingga dapat diabaikan (karena operasi yang dilakukan adalah
mengubah-ubah atau mencaric). Oleh karena itu, persamaan 8.8 dapat
disederhanakan menjadi 8.9.

```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)P(c 1 ,c 2 ,...,cT)
```
(8.9)
Pada persamaan 8.9, kombinasi sekuens kelas kata jauh lebih sedikit dibanding
kombinasi sekuens kata (karena kelas kata jumlahnya lebih terbatas). Ingat
kembaliP(c 1 ,c 2 ,...,cT) disebut _prior_,P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT)
disebut _likelihood_ (bab 2).
Persamaan 8.9 masih dapat disederhanakan kembali menggunakanmarkov
assumption, yaitu dengan membuat asumsi saling lepas pada sekuens (disebutindependence
assumption). Terdapat dua asumsi, pertama, kategori
suatu kata hanya bergantung pada dirinya sendiri tanpa memperhitungkan
kelas kata disekitarnya, seperti pada persamaan 8.10. Asumsi kedua adalah
suatu kemunculan kategori kata hanya bergantung pada kelas kata sebelumnya,
seperti pada persamaan 8.11.

```
P(w 1 ,w 2 ,...,wT|c 1 ,c 2 ,...,cT) =
```
#### ∏T

```
i=1
```
```
P(wi|ci) (8.10)
```
```
P(c 1 ,c 2 ,...,cT) =
```
#### ∏T

```
i=1
```
```
P(ci|ci− 1 ) (8.11)
```
Dengan demikian, persamaan 8.9 disederhanakan kembali menjadi persamaan
8.12 yang disebut _bigram assumption_ atau _first-order markov chain_,
dimanaTmelambangkan panjangnya sekuens.

```
cˆ 1 ,cˆ 2 ,...,cˆT= arg max
c 1 ,c 2 ,...,cT;ciC
```
#### ∏T

```
i=1
```
```
P(wi|ci)P(ci|ci− 1 ) (8.12)
```
Kita dapat membuat ekstensi persamaan 8.12 dengan _trigram assumption_, _quadgram_
assumption, dan seterusnya.P(ci|ci− 1 ,ci− 2 ) untuk _trigram_,P(ci|ci−
1 ,ci− 2 ,ci− 3 ) untuk _quadgram_. Walau menghitung probabilitas
seluruh sekuens adalah hal yang susah, hal tersebut dapat di _model_ kan dengan

108 8 Hidden Markov Model

lebih baik menggunakan _recurrent neural network_ (subbab 13.2). Anda dapat
membaca subbab tersebut kemudian, ada baiknya kita mengerti pendekatan
yang lebih sederhana terlebih dahulu.
Sebagai contoh, untuk kalimat “ _budi menendang bola_ ”, peluang kalimat
tersebut memiliki sekuens kelas kata “ _noun_, _verb_, _noun_ ” adalah

```
P( _noun_, _verb_, _noun_ ) =P(budi| _noun_ )P( _noun_ |null)P(menendang| _verb_ )
P( _verb_ | _noun_ )P(bola| _noun_ )P( _noun_ | _verb_ )
(8.13)
```


### 6.3 Isu pada ID3

Pada algoritma _decision tree_ secara umum, terdapat beberapa isu diantara
lain [7, 36]:

1. Mudah overfitting
2. Masalah menangani atribut kontinu
3. _Information gain_ memiliki bias terhadap atribut yang memiliki banyak
    nilai ( _highly-branching attributes_ )
4. Data dengan _missing value_. Beberapa sel pada tabel dataset tidak terisi.
5. Data dengan _unseen value_. Misal nilai atribut yang tidak pernah dilihat
    pada _training data_, muncul saat _testing_.


### 6.1 Inductive Learning

Salah satu bentuk “kecerdasan” sederhana kemungkinan adalah dalam bentuk
aturan ( _rule_ ) yang merepresentasikan pengetahuan. Misalkan, untuk
menentukan apakah suatu pasien terserang penyakit tertentu, dokter mencari
tahu gejala-gejala yang ada. Berdasarkan gejala-gejala yang ada, dokter
memutuskan bahwa pasien memiliki suatu penyakit. Pada zaman dahulu,
peneliti mentranskripsi aturan-aturan ( _if then_ ) eksplisit (berdasarkan pengetahuan
ahli) untuk membuat agen cerdas ( _expert system_ ). Aturan sangat
berguna, tetapi proses transkripsi pengetahuan sang ahli menjadi aturan formal
(matematis) adalah hal yang sulit. Terlebih lagi, aturan-aturan yang sudah
dibangun cenderung tidak dapat diubah dengan mudah.
Pada era _big data_ seperti sekarang, kita dapat mengotomatisasi hal tersebut
dengan membuat aturan-aturan secara otomatis berdasarkan contoh data
yang ada ( _machine learning_ ). Pendekatan ini disebut _inductive learning_, yaitu
mengembangkan aturan klasifikasi yang dapat menentukan kelas suatu _instance_ berdasarkan
nilai atributnya ( _feature vector_ ). Cara paling sederhana
diberikan pada subbab 3.3 yaitu mendaftarkan seluruh kemungkinan aturan
yang ada, kemudian menghapus yang kurang cocok. Algoritma lebih baik
adalah dengan membangun pohon keputusan ( _decision tree_ ).

84 6 Pohon Keputusan


### Soal Latihan

6.1. Isu
Pada subbab 6.3, telah disebutkan isu-isu yang ada pada ID3, sebutkan dan
jelaskan bagaimana cara menangani masing-masing isu tersebut!

6.2. Gain Ratio
Selain _information gain_, kita dapat menggunakan cara lain untuk memilih
atribut bernama _gain ratio_. Jelaskan perbedaan keduanya! Yang mana lebih
baik?

6.3. C4.5
ID3 disempurnakan kembali oleh pembuat aslinya menjadi C4.5. Jelaskanlah
perbedaan ID3 dan C4.5, beserta alasan st _rate_ gi penyempurnaan!

6.4. Pruning
Jelaskan apa itu _pruning_ dan bagaimana cara melakukan _pruning_ untukdecision
tree!

6.5. Association Rule
Terdapat beberapa algoritma _association rule_ yang membentuk aturan-aturan
seperti _decision tree_.
(a) Jelaskanlah algoritma PRISM dan A _prior_ i!
(b) Jelaskan perbedaan _association rule_ dan _inductive learning_ !

6.6. Final Decision Tree
Lanjutkanlah proses konstruksi ID3 untuk Tabel 6.1 hingga membentukdecision
treeakhir seperti pada Gambar 6.1!

6.7. Variant
Jelaskanlah _Random Forest_, _Bagging_ dan _Boosting_ pada _Decision Tree_ !


### 6.2 ID3

_Decision tree_  adalah varian dari _inductive learning_. ID3 adalah salah satu
algoritma varian _decision tree_ [34]. _Decision tree_ dibangun berdasarkan asumsi
bila atribut yang ada memberikan informasi yang cukup memadai maka kita
mampu membangun _decision tree_ yang mampu mengklasifikasikan seluruh
_instance_ di _training data_ [34]. Akan tetapi, kita tentunya ingin melakukan
generalisasi, yaitu _decision tree_ yang juga mampu mengklasifikasikan objek
dengan benar untuk _input_ yang tidak ada di _training data_ ( _unseen instances_ ).
Oleh karena itu, kita harus mampu mencari hubungan antara kelas dan nilai
atribut.

```
Gambar 6.1:Final decision tree
```
```
id outlook temperature humidity windy play ( _class_ )
1 sunny hot high false no
2 sunny hot high true no
3 overcast hot high false yes
4 rainy mild high false yes
5 rainy cool normal false yes
6 rainy cool normal true no
7 overcast cool normal true yes
8 sunny mild high false no
9 sunny cool normal false yes
10 rainy mild normal false yes
11 sunny mild normal true yes
12 overcast mild high true yes
13 overcast hot normal false yes
14 rainy mild high true no
```
```
Tabel 6.1: Contoh dataset _play tennis_ (UCI machine learning repository).
```

```
6.2 ID3 85
```
St _rate_ gi pembangunan ID3 adalah berdasarkan _top-down_ rekursif. Pertama,
kita pilih atribut untuk _root_ pohon, lalu membuat cabang untuk setiap
nilai atribut yang mungkin. Untuk masing-masing cabang, kita buat _subtree_.
Kita hentikan proses ini ketika kita sudah mencapai _leaf_ (tidak bisa mencabang
lebih jauh). _Leaf_ ditandai apabila seluruh _instance_ pada cabang tersebut
memiliki kelas yang sama. Atribut yang sudah dipilih pada _ancestor_ tidak
akan dicoba pada percabangan di cabang tertentu.
Sebagai contoh, perhatikanlah Gambar 6.1 yang merupakan hasil ID3
untuk Tabel 6.1. Bentuk elips merepresentasikan nama atribut, sementara
_edge_ (panah) merepresentasikan nilai atribut. Bentuk segi empat merepresentasikan
klasifikasi kelas ( _leaf_ ). Pohon keputusan pada Gambar 6.1 dapat
dikonversi menjadi kumpulan aturan klasifikasi berbentuk logika preposisi
dengan menelusuri setiap cabang pada pohon tersebut, yaitu:

- if _outlook=sunny_ and _humidity=high_ then _play=no_
- if _outlook=sunny_ and _humidity=normal_ then _play=yes_
- if _outlook=overcast_ then _play=yes_
- if _outlook=rainy_ and _windy=false_ then _play=yes_
- if _outlook=rainy_ and _windy=true_ then _play=no_

Karena _decision tree_ dapat interpretasikan sebagai logika preposisi, model ini
tergolong _interpretable_. Artinya, manusia dapat mengerti proses yang terjadi
pada model dengan mudah.
Pada setiap langkah membangun ID3, kita menggunakaninformation
gainuntuk memilih kandidat atribut terbaik. _Information gain_ mengukur
kemampuan suatu atribut untuk memisahkan _training data_ berdasarkan kelas
[7].
Sebelum masuk ke perumusan _information gain_, penulis akan mengingatkan _entropy_ terlebih
dahulu. Entropy (derajat ketidakteraturan) adalah
informasi yang dibutuhkan untuk memprediksi sebuah kejadian, diberikan
distribusi probabilitas. Secara matematis, entropy didefinisikan pada persamaan
6.1 (xadalah kumpulan nilai probabilitas).

```
_entropy_ (x) =−
```
#### ∑N

```
i=1
```
```
xilogxi (6.1)
```
Kita juga definisikanInfo sebagai persamaan 6.2, dimana ci adalah
banyaknya instance diklasifikasikan sebagai kelas ke-i (atau secara lebih
umum, ke _node_ -i).

86 6 Pohon Keputusan

```
Info(c 1 ,c 2 ,...,cN) = entropy(
```
```
c 1
∑N
j cj
```
#### ,

```
c 2
∑N
j cj
```
#### ,...,

```
cN
∑N
j cj
```
#### ) (6.2)

_Information gain_ dihitung sebagai persamaan 6.3, dimanaciadalah jumlah _instance_ untuk
kelas ke-i,vadalah nilai atribut,cvadalah banyaknya
_instance_  ketika dicabangkan dengan nilai atributv,cvxadalah banyaknya
_instance_ kelas saat percabangan. _Information gain_ dapat dimaknai sebagai
pengurangan entropy karena melakukan percabangan.

```
IG(c 1 ,c 2 ,...,cN) = Info(c 1 ,c 2 ,...,cN)−
```
#### ∑

```
vV
```
```
cv
∑N
i=1ci
```
```
Info(c 1 v,c 2 v,...,cNv)
```
(6.3)
Sebagai contoh, mari kita hitung _Information gain_ untuk atribut _outlook_
sebagai _root_. Dari keseluruhan data terdapat 9 _instance_ untuk _play=yes_ dan
5 instanceuntuk _play=no_. Kita hitung Info semesta sebagai (logbasis 2)

```
Info([9,5]) = entropy
```
#### ([

#### 9

#### 14

#### ,

#### 5

#### 14

#### ])

#### =−

#### 9

#### 14

```
log
```
#### (

#### 9

#### 14

#### )

#### −

#### 5

#### 14

```
log
```
#### (

#### 5

#### 14

#### )

#### = 0. 940

Kita hitung _entropy_ untuk masing-masing nilai atribut _outlook_ sebagai berikut:

- outlook=sunny
    Ada dua _instance_ dengan _play=yes_ dan tiga _instance_ dengan _play=no_
    saat _outlook=sunny_, dengan demikian kita hitung Info-nya.

```
Info([2,3]) = entropy
```
#### (

#### 2

#### 5

#### ,

#### 3

#### 5

#### )

#### =−

#### 2

#### 5

```
log
```
#### (

#### 2

#### 5

#### )

#### −

#### 3

#### 5

```
log
```
#### (

#### 3

#### 5

#### )

#### = 0. 971

- outlook=overcast
    Ada empat _instance_ dengan _play=yes_ dan tidak ada _instance_ dengan
    play=nosaat _outlook=overcast_, dengan demikian kita hitung Info-nya.

```
Info([4,0]) = entropy
```
#### (

#### 4

#### 4

#### ,

#### 0

#### 4

#### )

#### =−

#### 4

#### 4

```
log
```
#### (

#### 4

#### 4

#### )

#### −

#### 0

#### 4

```
log
```
#### (

#### 0

#### 4

#### )

#### = 0

```
Perhatikan log 0 pada matematika adalah tidak terdefinisi, tapi kita
anggap 0 log 0 sebagai 0 dalam komputasi.
```

```
6.2 ID3 87
```
- outlook=rainy
    Ada tiga _instance_ dengan _play=yes_ dan dua _instance_ dengan _play=no_
    saat _outlook=rainy_, dengan demikian kita hitung Info-nya.

```
Info([3,2]) = _entropy_
```
#### (

#### 3

#### 5

#### ,

#### 2

#### 5

#### )

#### =−

#### 3

#### 5

```
log
```
#### (

#### 3

#### 5

#### )

#### −

#### 2

#### 5

```
log
```
#### (

#### 2

#### 5

#### )

#### = 0. 971

Kita hitung _information gain_ untuk atribut _outlook_ sebagai

```
IG( _outlook_ ) = Info ([9,5])−
(
5
14
```
```
×Info ([3,2]) +
```
#### 4

#### 14

```
×Info([4,0]) +
```
#### 5

#### 14

```
×Info([3,2])
```
#### )

#### = 0. 940 −

#### (

#### 5

#### 14

#### × 0 .971 +

#### 4

#### 14

#### ×0 +

#### 5

#### 14

#### × 0. 971

#### )

#### = 0. 940 − 0. 693

#### = 0. 247

Dengan metode yang sama, kita hitung _information gain_ untuk atribut lain-
nya.

- IG(temperature) = 0. 029
- IG( _humidity_ ) = 0. 152
- IG(windy) = 0. 048

Dengan demikian, kita memilih atribut _outlook_ sebagai _root_.
Kita lanjutkan lagi membuat _subtree_ setelah memilih atribut _outlook_ sebagai _root_.
Kita hitung atribut yang tepat pada cabangoutook=sunny, seperti
diilustrasikan pada Gambar 6.2.
Pada _outlook=sunny_, terdapat dua _instance_ dengan kelas _play=yes_
dan tiga _instance_ dengan kelas _play=no_. Kita hitung _information gain_ saat
melanjutkan cabang dengan atribut _humidity_.

```
IG( _humidity_ ) = Info([2,3])−
```
#### (

#### 3

#### 5

```
×Info([0,3]) +
```
#### 2

#### 5

```
×Info([2,0])
```
#### )

#### = 0. 971 − 0

#### = 0. 971

Untuk setiap kedalaman, kita coba menggunakan atribut yang belum pernah
dicoba pada level-level lebih atas, seperti yang sudah diilutrasikan. Proses ini
dilanjutkan sampai kita tidak bisa atau tidak perlu mencabang lagi.

88 6 Pohon Keputusan

```
Gambar 6.2: Percabangan
```


### 6.4 Pembagian Ruang Konsep

Ada hubungan antara algorithma _decision tree_ dan model linear. Pada model
linear, kita semacam membagi-bagi ruang konsep (semesta data) menjadi ruang
per kelas menggunakan garis pembatas linear. _Decision tree_ melakukan
hal yang hampir sama, karena percabangan _decision tree_ dapat dianggap sebagai
linear. Sebagai contoh perhatikan ilustrasi Gambar 6.3, dimana semesta
adalah suatu ruang konsep. Tiap ruang merepresentasikan suatu cabang (dari
_root_ sampai leaf) pada _decision tree_. Garis-garis yang membentuk ruangruang
pemisah disebut sebagai _decision boundary_.

```
6.4 Pembagian Ruang Konsep 89
```
```
Gambar 6.3: Ilustrasi pembagian ruang konsep
```


### Soal Latihan

10.1. Intra- _cluster_ Evaluation
Buktikan kebenaran persamaan 10.7.

10.2. Entropy
Bagaimana cara menghitung kualitas algoritma _clustering_, jika diberikan informasi
label/ kelas setiap data menggunakan: (hint, baca [41])
(a) Entropy
(b) Purity

10.3. Kompleksitas
Hitunglah kompleksitas algoritma untuk:
(a) K- _mean_ s
(b) Agglomerative Clustering
(c) Divisive Clustering

10.4. Kemiripan Data
Sebutkanlah contoh perhitungan kemiripan untuk data _string_. Bagaimana
adaptasi perhitungan tersebut pada formula-formula yang sudah diberikan
pada algoritma K- _mean_ s dan agglomerative clustering.

10.5. Agglomerative vs Divisive Clustering
Menurut kamu, mengapa pendekatan _bottom-up_ (agglomerative) lebih populer
dibanding _top-down_ (divisive)? Apa perbedaan kedua pendekatan tersebut
(keuntungan dan kerugian masing-masing)?

10.6. Agglomerative Link
Jelaskan apa kelebihan dan kekurangan masing-masing metode perhitungan
kemiripan cluster pada agglomerative clustering!


### 10.3 Evaluasi

Diberikan sekumpulan dataD={d 1 ,d 2 ,···,dN}untuk suatu _cluster_. Saat
tidak tersedianya informasi label/kelas untuk setiap data, kualitas hasil _clustering_ dapat
dihitung dengan tiga kriteria yaitu:

```
1. _Intra-cluster similarity_, yaitu menghitung rata-rata kedekatan antara
suatu anggota dan anggota _cluster_ lainnya.
```
```
I=
```
#### 1

#### N^2

#### ∑

```
didj,i 6 =j
```
```
cosSim(di,dj) (10.6)
```
```
Perhitungan kedekatan antar tiap pasang anggota _clusters_ ama halnya
dengan menghitung _norm_ dari centroid _cluster_ tersebut, ketika centroid
dihitung menggunakan _mean_ (buktikan!).
```
```
I=
```
#### 1

#### N^2

#### ∑

```
didj,i 6 =j
```
```
cosSim(di,dj) =‖c‖^2 (10.7)
```
```
Perhitungan ini dapat di _norm_ alisasi sesuai dengan banyaknya anggota
_cluster_
I′=
‖c‖^2
N
```
#### (10.8)

```
Semakin tinggi kemiripan anggota pada suatu _cluster_, semakin baik kualitas
_cluster_ tersebut.
```
```
2. _Inter-cluster similarity_, yaitu menghitung bagaimana perbedaan antara
suatu _cluster_ dan _cluster_ lainnya. Hal tersebut dihitung dengancosine
similarity antara centroid suatu _cluster_ dan centroid dari seluruh
_data_  [42], dimanackadalah centroid _cluster_ ke-k,cDadalah centroid
( _mean_ ) dari seluruh data,Nkadalah banyaknya anggota _cluster_ ke-k, dan
Kadalah banyaknya _clusters_. Semakin kecil nilai _inter-cluster similarity_,
maka semakin baik kualitas _clustering_.
```
#### E=

#### ∑K

```
k=1
```
```
Nk
ckcD
‖ck‖
```
#### (10.9)

```
3. _Hybrid_. Perhitungan intra- _cluster_ dan inter- _cluster_ mengoptimalkan
satu hal sementara tidak memperdulikan hal lainnya. _Intra-cluster_ menghitung
keeratan anggota _cluster_, sementara _Inter-cluster_ menghitung separasi
antar _clusters_. Kita dapat menggabungkan keduanya sebagai _hybrid_
(gabungan), dihitung dengan:
```
#### H=

#### ∑K

```
k=1I
′
k
E
```
#### =

#### ∑K

```
k=1
```
```
‖ck‖^2
Nk
∑K
k=1Nk
```
```
ckcD
‖ck‖
```
#### =

#### ∑K

```
k=1
```
```
‖ck‖
Nk^2 ckcD
```
#### (10.10)

```
Semakin besar nilai perhitungan _hybrid_, semakin bagus kualitas _clusters_.
```

140 10 Clustering

Apabila terdapat informasi label/ kelas untuk setiap data, kita juga dapat
menghitung kualitas algoritma _clustering_ (perhatikan! tujuan pengukuran
adalah kualitas algoritma) dengan _Entropy_ danPurity.