### 5.4 Multi- _class_ Classification

Subbab ini akan membahas tentang _multi-class classification_, dimana terdapat
lebih dari dua kemungkinan kelas. Terdapat himpunan kelasCberanggotakan
{c 1 ,c 2 ,...,cK}. Untuk suatu data dengan representasi _feature vector_ -nya, kita
ingin mencari tahu kelas yang berkorespondesi untuk data tersebut. Contoh

```
5.4 Multi- _class_ Classification 67
```
permasalahan ini adalah mengklasifikasi gambar untuk tiga kelas: _apel_,jeruk,
atau _mangga_. Cara sederhana adalah memiliki tiga buah vektor parameter
dan _bias_ berbeda,w _apel_,wjeruk,w _mangga_, dan _bias_ b{ _apel_,jeruk, _mangga_ }. Untuk
menentukan suatu data masuk ke kelas mana, kita dapat memprediksi skor
tertinggi yang diberikan oleh operasi _feature vector_ terhadap masing-masing
_vektor_  parameter. Konsep matematisnya diberikan pada persamaan 5.12, dimana
ˆcadalah kelas terpilih (keputusan), yaitu kelas yang memiliki nilai tertinggi.Cmelambangkan
himpunan kelas.

```
c _apel_ =x·w _apel_ +b _apel_
cjeruk=x·wjeruk+bjeruk
c _mangga_ =x·w _mangga_ +b _mangga_
ˆc= arg max
ci∈C
```
```
(ci)
```
#### (5.12)

Tiga set parameter wci dapat disusun sedemikian rupa sebagai matriks
W∈Rd×^3 , dimanadadalah dimensi _feature vector_ (x∈R^1 ×d). Demikian
pula kita dapat susun bias menjadi vektorb∈R^1 ×^3 berdimensi tiga. Dengan
demikian, persamaan 5.12 dapat ditulis kembali sebagai persamaan 5.13, dimanacadalah
_vektor_  yang memuat nilai fungsi terhadap seluruh kelas. Kita
memprediksi kelas berdasarkan indeks elemencyang memiliki nilai terbesar
(persamaan 5.14). Analogika, seperti memilih kelas dengan nilai _likelihood_
tertinggi.

```
c=f(x) =x·W+b (5.13)
```
```
ˆc= arg max
ci∈c
```
```
(ci) (5.14)
```
Seperti yang diceritakan pada subbab berikutnya, kita mungkin juga tertarik
dengan probabilitas masing-masing kelas, bukan hanya _likelihood_ -nya.
Kita dapat menggunakan fungsi _softmax_ ^3 untuk hal ini. Fungsi _softmax_ mentransformasicagar
jumlah semua nilainya berada pada range [0,1]. Dengan
itu,cdapat diinterpretasikan sebagai distribusi probabilitas. Konsep ini dituangkan
pada persamaan 5.15, dimanaciadalah elemen vektor ke-i, melambangkan
probabilitas masuk ke kelas ke-i.

```
ci=
e(x·W+b)[i]
∑
je
```
```
(x·W+b)[j] (5.15)
```
Karena _output_ fungsi berupa distribusi probabilitas, kita juga dapat menghitung _loss_ menggunakancross
_entropy_. Seperti yang sudah dijelaskan sebelumnya
pada _binary classification_, kita ingin hasil perhitungan _cross entropy_ seke-

(^3) https://en.wikipedia.org/wiki/Softmax_ _function_

68 5 Model Linear

cil mungkin karena meminimalkan nilai _cross entropy_ meningkatkan _confidence_ saat
proses klasifikasi. Hal ini dapat dianalogikan dengan jargon “winner
takes it all”. Sebagai ilustrasi, lihatlah Gambar 5.5. Kita ingin agar bentuk
distribusi probabilitas _output_ kelas (c) condong ke salah satu sisi saja.

```
Gambar 5.5:Classification Entropy.
```
```
Gambar 5.6:One versus one.
```

```
5.4 Multi- _class_ Classification 69
```
```
Gambar 5.7:One versus all.
```
Selain mengekstensi suatu model untuk melakukan _multi-class classification_ secara
langsung, kita juga dapat menggabungkan beberapa model _binary_
_classifier_ untuk melakukan _multi-class classification_. Teknik ini memiliki dua
varian yaitu _one versus one_ dan _one versus all_.
Pada teknik _one versus one_, kita membuat sejumlah kombinasi pasangan
kelas

#### (N

```
2
```
#### )

, untukN= banyaknya kelas. Kemudian, kita biarkan masingmasing
_model_  mengklasifikasikan _input_ ke dalam satu dari dua kelas. Akhirnya,
kita memilih kelas klasifikasi berdasarkan kelas yang paling sering muncul dari
semua model. Hal ini diilustrasikan pada Gambar 5.6 (untuk lima kelas), dimanafi,jmelambangkan _binary_
_classifier_ untuk kelasidan kelasj.
Pada teknik _one versus all_, kita membuat sejumlah model juga, tetapi
kombinasinya tidak sebanyak _one versus one_. Model pertama mengklasifikasikan _inputs_ ebagai
kelas pertama atau bukan kelas pertama. Setelah itu,
dilanjutkan ke model kedua mengklasifikasikan _inputs_ ebagai kelas kedua atau
bukan kelas kedua, dan seterusnya. Hal ini diilustrasikan pada Gambar 5.7
(untuk lima kelas).

70 5 Model Linear


### 5.5 Multi-label Classification

Seperti halnya _multi-class classification_, kita dapat mendekomposisimultilabel
_classification_ menjadi beberapa _binary classifier_ (analogi persamaan 5.12).
Yang membedakan _multi-class_ dan _multi-label_ adalah outputc. Padamulti _class_
_classification_,ci∈cmelambangkan skor suatu _input_ masuk ke kelas
ci. Keputusan akhir _class assignment._ idapatkan dari elemencdengan nilai
terbesar. Untuk _multi-label classification_ nilaici∈cmelambangkan apakah
suatu kelas masuk ke kelasciatau tidak. Bedanya, kita boleh meng- _assign_
lebih dari satu kelas (atau tidak sama sekali). Misalci≥ 0 .5, artinya kita
anggap model tersebut layak masuk ke kelasci, tanpa harus membandingannya
dengan nilaicj(i 6 =j) lain. Inilah yang dimaksud dengan prinsipmutual
exclusivity. Perhatikan Tabel 5.1 sebagai ilustrasi, dimana “1” melambangkan
_class assignment._

```
InstanceAgama Politik Hiburan
Berita-1 1 0 0
Berita-2 0 1 0
Berita-3 0 0 1
```
```
(a) Multi- _class_ classification.
```
```
InstanceAgama Politik Hiburan
Berita-1 1 1 0
Berita-2 0 1 1
Berita-3 1 0 1
```
```
(b) Multi-label classification.
```
Tabel 5.1: Ilustrasi _multi-label_ dan _multi-class classification_. Nilai “1” melambangkan
TRUE dan “0” melambangkan FALSE ( _class assignment._.

Sekali lagi, nilaici∈cbernilai [0,1] tetapi keputusan klasifikasi apakah
suatu kelas masuk ke dalamcitidak bergantung pada nilaicj(i 6 =j) lainnya.
Berdasarkan prinsip _mutual exclusivity_, output cpada classifier 5.7
tidak ditransformasi menggunakan _softmax_. Pada umumnya, _multi-label classifier_ melewatkan _output_ cke
dalam fungsi sigmoid. Dengan demikian, persamaan
5.15 diganti menjadi persamaan 5.16 pada _multi-label classifier_.

ci= sigmoid(ci) (5.16)
Berhubung cara menginterpretasikan _output_ berbeda dengan _multi-class_
_classification_, cara evaluasi kinerja juga berbeda. Ada dua pendekatan evaluasi
pada _multi-label classification_. Pertama, kita evaluasi kinerja _binary classification_ untuk
setiap kelas. Pada pendekatan ini, seolah-olah kita memiliki
banyak _binary classifier_ untuk melakukan klasifikasi. Kedua, kita dapat
mengevaluasi kinerja _multi-label classification_ itu sendiri. Perhatikan Gambar
5.8! Pendekatan pertama ibarat membandingkan kolom _desired output_ untuk
masing-masing kelas dengan _prediction_ yang berkorespondensi. Pada pendekatan
kedua, kita membandingkan baris untuk tiap-tiap prediksi (seperti biasa).
Saat kita membandingkan tiap-tiap baris prediksi, kita bisa jadi menda-

```
5.6 Pembelajaran sebagai Permasalahan Optimisasi 71
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
```
```
Instance Agama Politik Hiburan
Berita- 1 1 1 0
Berita- 2 0 1 1
Berita- 3 1 0 1
```
```
Original
Instance Agama Politik Hiburan
Berita- 1 1 1 1
Berita- 2 0 1 1
Berita- 3 0 0 1
```
```
Prediction
```
```
Instance Agama Politik Hiburan
1 1 0
0 0 1
0 1 0
```
```
Exact match
Partially correct
Complete incorrect
```
```
Evaluate binary
_classification_  sepa _rate_ ly
```
```
Evaluate multi-label
_classification_  at once
Original Prediction
```
```
Gambar 5.8: Cara mengevaluasi _multi-label classifier_.
```
patkan prediksi tipe _exact match_ (seluruh prediksi sama dengan _desired output_ ),partially
correct(sebagian prediksi sama dengan _desired output_ ) atau
_complete incorrect_ (tidak ada prediksi yang sama dengan _desired output_ ).
Dengan ini, evaluasi _multi-label classification_ relatif lebih kompleks dibanding
_multi-class classification_ biasa. Untuk mendapatkan _multi-label classification_
accuracy, kita dapat menghitung berapa seberapa banyak _exact match_ dibandingkan
banyaknya _instance_ (walaupun hal ini terlalu ketat). Selain itu, kita
dapat menghitung _loss_ menggunakan _cross entropy_ untuk mengevaluasi kinerja
saat melatih _multi-label classifier_, layaknya _multi-class classifier_. Kamu
dapat membaca [29] lebih lanjut untuk teknik evaluasi _multi-label_ classifica-
tion.


### 5.7 Batasan Model Linear

Model linear, walaupun mudah dimengerti, memiliki beberapa batasan. Ada
dua batasan paling kentara [20]: (1) _additive assumption_ dan (2)linear as-
sumption.
_Additive assumption_ berarti model linear menganggap hubungan antara
_input_ dan _output_ adalah linear. Artinya, perubahan nilai pada suatu fiturxi
pada inputxakan merubah nilai _output_ secara independen terhadap fitur
lainnya. Hal ini terkadang berakibat fatal karena fitur satu dan fitur lainnya
dapat berinteraksi satu sama lain. Solusi sederhana untuk permasalahan ini
adalah dengan me _model_ kan interaksi antar-fitur, seperti diilustrasikan pada
persamaan 5.24 untuk _input_ yang tersusun atas dua fitur.

```
f(x) =x 1 w 1 +x 1 w 2 +x 1 x 2 w 3 +b (5.24)
```
Dengan persamaan 5.24, apabilax 1 berubah, maka kontribusix 2 terhadap
_output_ juga akan berubah (dan sebaliknya). Akan tetapi, seringkali interaksi

76 5 Model Linear

antar-fitur tidaklah sesederhana ini. Misal, semua fitur berinteraksi satu sama
lain secara non-linear.
_Linear assumption_ berarti perubahan pada suatu fiturximengakibatkan
perubahan yang konstan terhadap _output_, walaupun seberapa besar/kecil nilai
xitersebut. Seringkali, perubahan pada _output_ sesungguhnya bergantung juga
pada nilaixi itu sendiri, bukan hanya pada∆xi. Solusi sederhana untuk
permasalahan ini adalah me _model_ kan fungsi linear sebagai fungsi polinomial
dengan orde (M) tertentu, diilustrasikan pada persamaan 5.25. Akan tetapi,
pe _model_ an inipun tidaklah sempurna karena rawan _overfitting_.

```
f(x) =x 1 w 1 + +x^22 w 2 +···+xMMwM+b (5.25)
```
Asumsi yang sebelumnya dijelaskan pada pe _model_ an polinomial, dapat diekstensi
menjadi _generalized additive model_ (GAM) untuk mengatasi masalah
_linear assumption_, seperti diilustrasikan pada persamaan 5.26 [20]. Artinya,
kita melewatkan setiap fiturxipada suatu fungsigi, sehingga deltaxitidak
mengakibatkan perubahan yang konstan terhadap _output_. Ekstensi ini dapat
me _model_ kan hubungan non-linear antara fitur dan _output_.

```
f(x) =g 1 (x 1 ) + +g 2 (x 2 ) +···+gN(xN) +b (5.26)
```
Tetapi, GAM masih saja memiliki batasan _additive assumption_. Dengan
demikian, interaksi antar-variabel tidak dapat di _model_ kan dengan baik.


### 5.10 Transformasi Data

Seperti yang sudah dijelaskan sebelumnya, alangkah baik apabila semua data
memiliki hubungan secara linear atau bersifat _linearly separable_. Kenyataan-

(^10) https://en.wikipedia.org/wiki/Norm_(mathematics)
(^11) https://stats.stackexchange.com/questions/136895/
why-is-the-l1- _norm_ -in-lasso-not- _differentiable_

80 5 Model Linear

nya, kebanyakan data bersifat _non-linearly separable_. Kita dapat mentransformasi
_data_  yang bersifat _non-linearly separable_ menjadi _linearly-separable_ sebelum
menggunakan model linear untuk mengklasifikasikan data. Sebagai contoh,
perhatikan Gambar 5.15. Pada gambar bagian kiri, terdapat empat titik
yang _non-linearly separable_. Titik-titik itu ditransformasi sehingga menjadi
gambar bagian kanan. Fungsi transformasi yang digunakan diberikan pada
persamaan 5.30.

```
Gambar 5.15: Contoh transformasi [7].
```
```
φ(x,y) =
```
#### {√

```
x^2 +y^2 ≥ 2 →(4−x+‖x−y‖, 4 −x+‖x−y‖)
√
x^2 +y^2 ≤ 2 →(x,y)
```
#### (5.30)

Secara umum, fungsi transformasi tidaklah sesederhana contoh yang sudah
diberikan. Fungsi transformasi pada umumnya menambah dimensi data (misal
dari dua dimensi menjadi tiga dimensi). Beberapa fungsi transformasi (dikenal
juga dengan istilah _kernel_ ) yang terkenal diantaranya:^12

1. Fisher Kernel
2. Graph Kernel
3. Kernel Smoother
4. Polynomial Kernel
5. Radial Basis Function Kernel
6. String Kernel

Untuk penjelasan masing-masing _kernel_, silahkan membaca literatur lain lebih
lanjut. Model linear yang memanfaatkan fungsi-fungsi _kernel_ ini adalahsupport
vector machine(SVM) [31, 32]. Perhatikan, algorithma SVM sebenarnya
sangatlah penting. Akan tetapi, perlu kami informasikan bahwa buku ini tidak
memuat materi SVM secara detil. Dengan demikian, kami harap pembaca dapat
mencari referensi lain tentang SVM. Metode transformasi pun tidaklah

(^12) https://en.wikipedia.org/wiki/ _Kernel_ _method

```
5.11 Bacaan Lanjutan 81
```
sempurna, seperti yang akan dijelaskan pada bab 11, karena memang data secara
alamiah memiliki sifat yang non-linear. Dengan demikian, lebih baik apabila
kita langsung saja me _model_ kan permasalahan dengan fungsi non-linear.


### Soal Latihan

5.1. Hill Climbing
Baca dan jelaskanlah konsep Hill Climbing!

5.2. Variasi Optimisasi
Baca dan jelaskanlah variasi konsep optimisasi lain, selainstochastic gradient
descent!

5.3. Convex Optimization
Bacalah literatur yang memuat materi tentang _convex optimization_ ! Jelaskan
pada teman-temanmu apa itu fungsi _convex_ dan _concave_, tidak lupa isi materi
yang kamu baca! Bagaimana hubungan _convex optimization_ dan pembelajaran
mesin?

5.4. Sum of Squared Errors
Salah satu cara untuk mencari nilai parameter pada regresi adalah menggunakan
teknik _sum of squared errors_. Jelaskanlah bagaimana cara kerja metode
tersebut! (Hint: baca buku oleh James et al. [20])

5.5. Linear Discriminant Analysis
Jelaskan prinsip dan cara kerja _linear discriminant analysis_ ! (Hint: baca buku
oleh James et al. [20])


### 5.11 Bacaan Lanjutan

Kami harap pembaca mampu mengeksplorasi materi _kernel method_ dansupport
vector machine(SVM). Kami mencantumkan materi SVM pada buku ini
sedemikian pembaca mampu mendapatkan intuisi, tetapi tidaklah detil. Kami
sa _rank_ an kamu membaca pranalahttps://www.svm-tutorial.com/karena
ditulis dengan cukup baik. Mengerti materi SVM dan _convex optimization_
secara lebih dalam akan sangat membantu pada bab-bab berikutnya. Selain
itu, kami juga menya _rank_ an pembaca untuk melihat kedua pranala tambahan
tentang _learning rate_ dan momentum:

```
1.http:// _user_ s.ics.aalto.fi/jhollmen/dippa/ _node_ 22.html
2.http://www.willamette.edu/~gorr/ _class_ es/cs449/mom _rate_.html
```


### 5.6 Pembelajaran sebagai Permasalahan Optimisasi

Salah satu tujuan dari pembelajaran ( _training_ ) adalah untuk meminimalkan
_error_  sehingga kinerja learning machine ( _model_ ) diukur oleh squared error.
Dengan kata lain, _utility function_ adalah meminimalkan _squared error_.
Secara lebih umum, kita ingin meminimalkan/memaksimalkan suatu fungsi
yang dijadikan tolak ukur kinerja ( _utility function_ ), diilustrasikan pada per-

72 5 Model Linear

samaan 5.17, dimanaθadalah _learning parameter_,^4 ˆθadalah nilai parameter
paling optimal, danLadalah _loss function_. Perhatikan, “arg min” dapat juga
diganti dengan “arg max” tergantungoptimisasiapa yang ingin dilakukan.
Perubahan parameter dapat menyebabkan perubahan _loss_. Karena itu, _loss_
_function_ memilikiθsebagai parameternya.

```
θˆ= arg min
θ
```
```
L(θ) (5.17)
```
Sekarang, mari kita hubungkan dengan contoh yang sudah diberikan pada
subbab sebelumnya. Kita coba melakukan estimasi _minimum squared error_ E,
dengan mencari nilai _learning parameters_ wyang meminimalkan nilai _error_
pada model linear (persamaan 5.18).^5 Parameter model pembelajaran mesin
_bias_ anya diinisialisasi secara acak atau menggunakan distribusi tertentu. Terdapat
beberapa cara untuk memimalkan _squared error_. Yang penulis akan
bahas adalah _stochastic gradient descent method_.^6 Selanjutnya apda buku ini,
istilah _gradient descent_, _gradient-based method_ dan _stochastic gradient descent_
mengacu pada hal yang sama.

```
wˆ= arg min
w
```
```
E(w) (5.18)
```
Bayangkan kamu sedang berada di puncak pegunungan. Kamu ingin mencari
titik terendah pegunungan tersebut. Kamu tidak dapat melihat keseluruhan
pegunungan, jadi yang kamu lakukan adalah mencari titik terendah
(lokal) sejauh mata memandang, kemudian menuju titik tersebut dan menganggapnya
sebagai titik terendah (global). Layaknya asumsi sebelumnya,
kamu juga turun menuju titik terendah dengan cara melalui jalanan dengan
kemiringan paling tajam, dengan anggapan bisa lebih cepat menuju ke titik
terendah [9]. Sebagai ilustrasi, perhatikan Gambar 5.9! Seluruh area pegunungan
adalah nilai _error_ E yang mungkin (pada persoalanmu), dan titik
terendah pada daerah tersebut adalah nilai _error_ Eterendah.
Jalanan dengan kemiringan paling tajam adalah−grad E(w), dimana
E(w) adalah nilai _error_ saat model memiliki parameterw. Dengan definisi
gradE(w) diberikan pada persamaan 5.19 dan persamaan 5.20, dimanawi
adalah nilai elemen vektor ke-i.

```
gradE(w) =
```
#### (

#### ∂E

```
∂w 1
```
#### ,

#### ∂E

```
∂w 2
```
#### ,...,

#### ∂E

```
∂wF
```
#### )

#### (5.19)

(^4) Dapat berupa skalar, vektor, matriks, atau tensor. Demi istilah yang lebih generik,
kita gunakanθ.
(^5) wboleh diganti denganW, saat ini penulis menggunakan vektor untuk menyedenakan
pembahasan.
(^6) Konsep _Hill Climbing_ dapat digunakan untuk memaksimalkan _utility function_
Konsep tersebut sangat mirip dengan _gradient descent_ https://en.wikipedia.
org/wiki/Hill_climbing.

```
5.6 Pembelajaran sebagai Permasalahan Optimisasi 73
```
```
Gambar 5.9:Stochastic Gradient Descent.
```
```
dw
dt
```
```
=−gradE(w);t= _time_ (5.20)
```
Ingat kembali materi diferensial. Gradien adalah turunan (diferensial)
fungsi. Untuk mencari turunan paling terjal, sama halnya mencari nilai
− _gradient_ terbesar. Dengan demikian, menghitung −grad E(w) terbesar
sama dengan jalanan turun paling terjal. Tentunya seiring berjalannya waktu,
kita mengubah-ubah parameterwagar kinerja model optimal. Nilai optimal
diberikan oleh turunanwterhadap waktu, yang bernilai sama dengan
−gradE(w). Bentuk diskrit persamaan 5.20 diberikan pada persamaan 5.21,

```
w(t+ 1) =w(t)−ηgradE(w(t)) (5.21)
```
dimanaηdisebut _learning rate_ danw(t) adalah nilaiwsaat waktu/iterasi
t. _Learning rate_ digunakan untuk mengatur seberapa pengaruh keterjalan
terhadap pembelajaran. Silahkan mencari sumber tambahan lagi agar dapat
mengerti _learning rate_ secara lebih dalam/matematis. Pada implementasi,η
juga sering diubah-ubah nilainya sepanjang waktu. Semakin kita sudah dekat
dengan tujuan (titik _loss_ terendah), kita mengurangi nilaiη, ibaratnya seperti
mengerem kalau sudah dekat dengan tujuan [30].
Walaupun kamu berharap bisa menuju titik terendah dengan menelusuri
jalan terdekat dengan kemiringan paling tajam, tapi kenyataanya hal tersebut
bisa jadi bukanlah jalan tercepat, seperti yang diilustrasikan pada Gambar
5.10. Warna merah melambangkan jalan yang dilalui _gradient descent_,
sementara warna biru melambangkan jalanan terbaik (tercepat).
Pandangan kita yang terbatas layaknya kita tidak bisa melihat keseluruhan
pengunungan secara keseluruhan (anggap ada kabut), kita juga tidak
bisa melihat keseluruhan nilai _error_ untuk semua parameterw. Secara filosofis,
hal tersebut juga berlaku saat membaca buku, oleh karena itu sebaiknya kamu
membaca beberapa buku saat belajar.
Dalam _local point of view_, _steepest gradient descent_ adalah cara tercepat
menuju titik terendah, tetapi tidak pada _global point of view_. Kita dapat
macet/berhenti saat sudah mencapai _local minima_, yaitu nilai minimum pada
suatu daerah lokal saja. Sebagai ilustrasi, perhatikan Gambar 5.11. Kamu
berada di puncak pegunungan kemudian turun bertahap. Kemudian, kamu
sampai di suatu daerah landai (−gradE(w) = 0). Kamu pikir daerah landai

74 5 Model Linear

```
Gambar 5.10:Stochastic Gradient Descent2.
```
```
Local Minima
−grad 𝐸𝒘 = 0
```
```
Global Minimum
−grad 𝐸𝒘 = 0
```
```
Start Point
```
```
Andaiaku
sebelumnya
meloncat!
```
```
Loncat
```
```
Gambar 5.11:Stuck at local minima.
```
tersebut adalah titik terendah, tetapi, kamu ternyata salah. Untuk menghindari
hal tersebut, kita menggunakan _learning rate_ (η). Apabila nilai _learning_
_rate_ (η) pada persamaan 5.21 relatif kecil, maka dinamika perubahan parameterwjuga
kecil. Tetapi, bila nilainya besar, maka jalanan menuju titik terendah
akan bergoyang-goyang ( _swing_ ), seperti pada Gambar 5.12. Goyangan
tersebut ibarat “meloncat-loncat” pada ilustrasi Gambar 5.11. Kemampuan
untuk “meloncat” ini dapat menghindarkan model _stuck_ di _local minima_.
Untuk mengontrol _learning parameter_ wsehingga memberikan nilaiE(w)
terendah, persamaan _steepest gradient descent_ dapat ditambahkan dengan

```
5.7 Batasan Model Linear 75
```
```
Gambar 5.12:Swing.
```
_momentum_  (α) pada persamaan 5.23. Alfa adalah momentum karena dikalikan
dengan hasil perbedaan descent pada tahap sebelumnya. Alfa adalah
parameter kontrol tambahan untuk mengendalikan _swing_ yang sudah dibahas
sebelumnya.

```
w(t+ 1) =w(t)−ηgradE(w(t)) +α(∆w) (5.22)
```
∆w=w(t)−w(t−1) (5.23)
Apabila gradien bernilai 0, artinya model sudah berada pada titiklocal/global
optimum. Kondisi ini disebut sebagaikonvergen( _converging_ ). Sementara
_model_  yang tidak menuju titik optimal, malah menuju ke kondisi
yang semakin tidak optimum, disebut _divergen_ ( _diverging_ ).


### 5.8 Overfitting dan Underfitting

Tujuan _machine learning_ adalah membuat model yang mampu memprediksi
_data_  yang belum pernah dilihat ( _unseen instances_ ) dengan tepat; disebut sebagai
generalisasi ( _generalization_ ). Seperti yang sudah dijelaskan pada bab
pertama, kita dapat membagi dataset menjadi _training_, _validation_, dan _testing_ _dataset_.
Ketiga dataset ini berasal dari populasi yang sama dan dihasilkan
oleh distribusi yang sama ( _identically and independently distributed_ ). Dalam
artian, ketiga jenis dataset mampu melambangkan (merepresentasikan) karakteristik
yang sama.^7 Dengan demikian, kita ingin _loss_ atau _error_ pada _training_, _validation_,
dan _testing_ bernilai kurang lebih bernilai sama (i.e., kinerja
yang sama untuk data dengan karakteristik yang sama). Akan tetapi, _underfitting_ dan _overfitting_ mungkin
terjadi.
_Underfitting_ adalah keadaan ketika kinerja model bernilai buruk baik pada
_training_  atau _validation_ maupun testing data. _Overfitting_ adalah keadaan
ketika kinerja model bernilai baik untuk _training_ tetapi buruk pada unseen
_data_. Hal ini diilustrasikan pada Gambar 5.13. _Underfitting_ terjadi akibat
_model_  yang terlalu tidak fleksibel, yaitu memiliki kemampuan yang rendah
untuk mengestimasi variasi fungsi. Sedangkan, _overfitting_ terjadi ketika

(^7) Baca teknik _sampling_ pada buku statistika.
(^8) Rekonstruksi https://www.inf.ed.ac.uk/teaching/courses/iaml/slides/
eval-2x2.pdf

```
5.8 Overfitting dan Underfitting 77
```
```
Gambar 5.13: _Underfitting_ vs _Overfitting_.^8
```
_model_  terlalu fleksibel, yaitu memiliki kemampuan yang terlalu tinggi untuk
mengestimasi banyak fungsi atau terlalu mencocokkan diri terhadap _training_ data.
Perhatikan kembali Gambar 5.13, dataset asli diambil ( _sampled_ )
dari fungsi polinomial orde-3. Model _underfitting_ hanya mampu mengestimasi
dalam orde-1 (kemampuan terlalu rendah), sedangkan model _overfitting_
mampu mengestimasi sampai orde-9 (kemampuan terlalu tinggi).
Apabila kita gambarkan grafik kinerja terhadap konfigurasi model ( _model_
order), fenomena underfitting dan overfitting dapat diilustrasikan seperti
Gambar 5.14. Model yang ideal adalah model yang memiliki kinerja yang baik
pada _training_, _validation_, dan _testing_ data. Artinya, kita ingin perbedaan kinerja
_model_  pada berbagai dataset bernilai sekecil mungkin. Untuk menghindari _overfitting_ atau _underfitting_,
kita dapat menambahkan fungsi _noise/bias_
(selanjutnya disebut _noise/bias_ saja) dan regularisasi (subbab 5.9). Hal yang
paling perlu pembaca pahami adalah untuk jangan merasa senang ketika
_model_  _machine learning_ yang kamu buat memiliki kinerja baik pada _training_
_data_. Kamu harus mengecek pada _validation_ dan _testing_ data, serta memastikan
kesamaan karakteristik data, e.g., apakah _training_ dan _testing_ data benar
diambil dari distribusi yang sama. Selain itu, kamu juga harus memastikan
apakah data yang digunakan mampu merepresentasikan kompleksitas pada
permasalahan asli/dunia nyata. Sering kali, dataset yang digunakan pada
banyak eksperimen adalah _toy dataset_, semacam simplifikasi permasalahan
dengan banyak sampel yang relatif sedikit. Kamu harus hati-hati terhadap

78 5 Model Linear

```
_Error_
```
```
Model order
```
```
_Training_  Error
```
```
Generalization (Testing) Error
```
```
_Underfitting_ Area Overfitting Area
```
```
Optimal Performance (Optimal Model)
```
```
Gambar 5.14:Selection Error.
```
_overclaiming_, i.e., menjustifikasi model dengan performa baik pada _toy dataset_
sebagai model yang baik secara umum.


### 5.3 Log-linear Binary Classification

Pada subbab sebelumnya, telah dijelaskan fungsi binary classifier memetakan
_data_  menjadi nilai [− 1 ,1], dengan−1 merepresentasikan kelas pertama dan
1 merepresentasikan kelas kedua. Tidak hanya kelas yang berkorespondensi,
kita juga terkadang ingin tahu seberapa besar peluang data tergolong pada
kelas tersebut. Salah satu alternatif adalah dengan menggunakan fungsi sigmoid
dibanding fungsi _sign_ untuk merubah nilai fungsi menjadi [0,1] yang
merepresentasikan peluangp _data_ diklasifikasikan sebagai kelas tertentu (1−p
untuk kelas lainnya). Konsep ini dituangkan menjadi persamaan 5.9, dimana
ymerepresentasikan probabilitas _input x_ digolongkan ke kelas tertentu,x
merepresentasikan data ( _feature vector_ ), danbmerepresentasikan _bias_. Ingat
kembali materi bab 4, algoritma _Naive Bayes_ melakukan hal serupa.
Hasil fungsi sigmoid, apabila di- _plot_ maka akan berbentuk seperti Gambar 5.1
(berbentuk karakter “S”).

66 5 Model Linear

```
y=σ(f(x)) =
```
#### 1

```
1 +e−(x·w+b)
```
#### (5.9)

Perhatikan, persamaan 5.9 juga dapat diganti dengan persamaan 5.10 yang
dikenal juga sebagai fungsi logistik.

```
y= logistik (f(x)) =
```
```
e(x·w+b)
1 +e(x·w+b)
```
#### (5.10)

Varibelyadalah nilai probabilitas data masuk ke suatu kelas. Sebagai contoh,
kita ingin nilaiy= 1 apabila data cocok masuk ke kelas pertama dany= 0
apabila masuk ke kelas kedua.
Ketika fungsi _machine learning_ menghasilkan nilai berbentuk probabilitas,
kita dapat menggunakan _cross entropy_ sebagai _utility function_. Persamaan
5.11 adalah cara menghitung _cross entropy_, dimanaT(ci) melambangkan
_desired probability_  ( _desired output_ ).P(ci) melambangkan probabilitas
(prediksi) _input_ diklasifikasikan ke kelasci danN melambangkan
banyaknya kelas. Untuk _binary classification_,T(c 1 ) = 1−T(c 2 ). Pada umumnya,Tbernilai
antara [0, 1]. Nilai 1 untuk kelas yang berkorespondensi dengan
_input_ ( _desired output_ ) dan 0 untuk kelas lainnya.

#### H=−

#### ∑N

```
i=1
```
```
T(ci) log (P(ci)) (5.11)
```
Kita ingin meminimalkan nilai _cross entropy_ untuk model pembelajaran
mesin yang baik. Ingat kembali materi teori informasi, nilai _entropy_ yang rendah
melambangkan distribusi tidak _uniform_. Sementara, nilai _entropy_ yang
tinggi melambangkan distribusi lebih _uniform_. Artinya, nilai _cross entropy_
yang rendah melambangkan _high confidence_ saat melakukan klasifikasi. Kita
ingin model kita se _bias_ a mungkin menghasilkan _output_ bernilai 1 untuk
mendiskriminasi seluruh data yang masuk ke kelas pertama, dan 0 untuk kelas
lainnya. Dengan kata lain, model dapat mendiskriminasi data dengan pasti.
_Cross entropy_ bernilai tinggi apabila perbedaan nilai probabilitas masuk ke
kelas satu dan kelas lainnya tidak jauh, e.g.,P(c 1 ) = 0.6 &P(c 2 ) = 0.4. Semakin
rendah nilai _cross entropy_, kita bisa meningkatkan “keyakinan” kita
terhadap kemampuan klasifikasi model pembelajaran mesin, yaitu perbedaan
nilai probabilitas masuk ke kelas satu dan kelas lainnya tinggi, e.g.,
P(c 1 ) = 0.8 &P(c 2 ) = 0.2.


### 5.2 Binary Classification

_Binary classification_ adalah mengklasifikasikan data menjadi dua kelas ( _binary_ ).
Contoh model linear sederhana untuk _binary classification_ diberikan
pada persamaan 5.6. Perhatikan, pada persamaan 5.6, suatu data direpresentasikan
sebagai _feature vector_ x, dan terdapat _bias_ b.^2 Klasifikasi dilakukan
dengan melewatkan data pada fungsi yang memiliki parameter. Fungsi tersebut
menghitung bobot setiap fitur pada vektor dengan mengalikannya dengan
parameter ( _dot product_ ). Persamaan 5.6 dapat ditulis kembali sebagai
persamaan 5.7, dimanaximerupakan elemen ke-idari vektorx. Fungsi ini
memiliki _range_ [−∞,∞]. Pada saat ini, kamu mungkin bingung. Bagaimana
mungkin fungsi regresi yang menghasilkan nilai kontinu digunakan untuk
klasifikasi kelas kategorial. Kita dapat menggunakan _thresholding_, atau dengan
memberikan batas nilai tertentu. Misal, bilaf(x)> thresholdmaka dimasukkan
ke kelas pertama; dan sebaliknyaf(x)≤ _threshold_ dimasukkan
ke kelas kedua. _Threshold_ menjadi bidang pembatas antara kelas satu dan
kelas kedua ( _decision boundary_, Gambar 5.3). Pada umumnya, teknik _threshold_ diterapkan
dengan menggunakan fungsi _sign_ (sgn, Gambar 5.4) untuk
merubah nilai fungsi menjadi [− 1 ,1] sebagai _output_ (persamaan 5.8); dimana
−1 merepresentasikan _input_ dikategorikan ke kelas pertama dan nilai 1 merepresentasikan _input_ dikategorikan
ke kelas kedua.

```
f(x) =x·w+b (5.6)
```
```
f(x) =x 1 w 1 +x 1 w 2 +···+xNwN+b (5.7)
```
_output_  = sgn(f(x) (5.8)
Seperti halnya fungsi regresi, kita juga dapat menghitung performa _binary_
_classifier_ sederhana ini menggunakan _squared error function_ (umumnya
menggunakan akurasi), dimana nilai target fungsi berada pada range [− 1 ,1].
Secara sederhana, model _binary classifier_ mencari _decision boundary_, yaitu
garis (secara lebih umum, _hyperplane_ ) pemisah antara kelas satu dan lainnya.
Sebagai contoh, garis hitam pada Gambar 5.3 adalah _decision boundary_.

(^2) Perhatikan! _Bias_ pada variabel fungsi memiliki arti yang berbeda dengan _statistical_
_bias_

```
5.3 Log-linear Binary Classification 65
```
```
Gambar 5.3: Contoh _decision boundary_.
```
```
Gambar 5.4: Fungsi _sign_.
```


### 5.9 Regularization

_Gradient-based method_ mengubah-ubah parameter modelwsehingga _loss_ dapat
diminimalkan. Perhatikan kembali Gambar 5.2, ibaratnya agar fungsi
aproksimasi kita menjadi sama persis dengan fungsi asli pada Gambar 5.1.
Perhatikan, karena nilaiwberubah-ubah seiring waktu, bisa jadi urutan _training_
_data_ menjadi penting.^9 Pada umumnya, kita menggunakan _batch method_
agar kinerja model tidak bias terhadap urutan data. Artinya, menghitung
_loss_ untuk beberapa data sekaligus. Hal ini akan kamu lebih mengerti setelah
mambaca bab 11.
Selain permasalahan model yang sensitif terhadap urutan _training data_,
_model_  yang kita hasilkan bisa jadi _overfitting_ juga. Yaitu memiliki kinerja
baik pada _training data_, tetapi memiliki kinerja buruk untuk _unseen data_.
Salah satu cara menghindari _overfitting_ adalah dengan menggunakan _regularization_.
Idenya adalah untuk mengontrol kompleksitas parameter (i.e. konfigurasi
parameter yang lebih sederhana lebih baik). Dengan ini, objektif _training_
pada persamaan 5.17 dapat kita ubah menjadi persamaan 5.27, dimana R(w)
adalah fungsi _regularization_ danλadalah parameter kontrol.

```
wˆ= arg min
w
```
```
L(w) +λR(w) (5.27)
```
(^9) Baca buku Yoav Goldberg [1] untuk mendapat penjelasan lebih baik.

```
5.10 Transformasi Data 79
```
Pilihan umum untuk fungsi _regularization_ pada umumnya adalahL 2 dan
L 1 norm. L 2 regularization menggunakan jumlah kuadrat dari Euclidean
_norm_ ^10 seluruh parameter, seperti pada persamaan 5.28. Sedangkan,L 1 regularizationmenggunakan
jumlah dari nilai _absolute-value norm_ seluruh parameter,
diberikan pada persamaan 5.29.

```
R(w) =‖w‖^22 =
```
#### ∑

```
i
```
```
(wi)^2 (5.28)
```
```
R(w) =‖w‖=
```
#### ∑

```
i
```
```
|wi| (5.29)
```
Perlu kamu perhatikan, metode _gradient descent_ memiliki syarat bahwa
fungsi yang digunakan haruslah dapat diturunkan ( _differentiable_ ).L 2 dapat
diturunkan pada seluruh poin, sementaraL 1 tidak dapat diturunkan pada semua
poin.^11 Kita dapat menggunakan teknik _subgradient_ untuk menyelesaikan
permasalahan ini. Kami serahkan pembaca untuk mengeksplorasi teknik tersebut
sendiri. Implikasi penggunakan regularisasi terhadap kompleksitas model
dibahas lebih lanjut pada bab 9.
Selain itu, ada hal lainnya yang perlu diperhatikan saat menggunakan
_gradient descent_ yaitu apakah suatu fungsi _convex_ atau _concave_. Izinkan saya
mengutip pernyataan dari buku Yoav Goldberg [1] halaman 31 secara langsung
menggunakan bahasa Inggris agar tidak ada makna yang hilang.

```
Convexity. In gradient-based optimization, it is common to distinguish between _convex_ (or _concave_ )
_function_ s and _non-concave_ functions. A _convex_
_function_ is a function whose second-derivative is always non-negative. As a
consequence, convex functions have a single minimum point. Similarly, _concave_
_function_ sare functions whose second-derivatives are always negative or
zero, and as a consequence have a single maximum point. Convex ( _concave_ )
_function_ s have the property that they are easy to minimize (maximize) using
_gradient-based optimization_ –simply follow the gradient until an extremum
_point_  is reached, and once it is reached we know we obtained the global extremum
_point_. In contrast, for functions that are neither convex or concave,
a gradient-based optimization procedure may converge to a local extremum
_point_, missing the global optimum.
```


### 5.1 Curve Fitting dan Error Function

Pertama, penulis ingin menceritakan salah satu bentuk _utility function_ untuk
_model_  matematis bernama _error function_. Fungsi ini sudah banyak diceritakan
pada bab-bab sebelumnya secara deskriptif. Mulai bab ini, kamu akan
mendapatkan pengertian lebih jelas secara matematis.
_Error function_  paling mudah dijelaskan dalam permasalahan regresi.
Diberikan (x,y)∈Rsebagai _random variable_. Terdapat sebuah fungsif(x)→
y, yang memetakanxkey, berbentuk seperti pada Gambar 5.1. sekarang
fungsif(x) tersebut disembunyikan (tidak diketahui), diberikan contoh-contoh
pasangan (xi,yi),i= 1, 2 ,...,6; yang direpresentasikan dengan lingkaran biru
pada ruang dua dimensi (titik sampel). Tugasmu adalah untuk mencari tahu
f(x)! Dengan kata lain, kita harus mampu memprediksi sebuah bilangan riil
y, diberikan suatux.
Kamu berasumsi bahwa fungsif(x) dapat diaproksimasi dengan fungsi
linearg(x) =xw+b. Artinya, kamu ingin mencariwdanbyang memberikan

62 5 Model Linear

```
Gambar 5.1: Contoh fungsi Sigmoid. Titik biru merepresentasikan sampel.
```
nilai sedemikian sehinggag(x) mirip denganf(x).wadalah parameter sementarabadalah _bias_.
Anggap kamu sudah berhasil melakukan pendekatan dan
menghasilkan fungsi linearg(x); seperti Gambar 5.2 (garis berwarna hijau).
Akan tetapi, fungsi approksimasi ini tidak 100% tepat sesuai dengan fungsi
aslinya (ini perlu ditekankan).^1 Jarak antara titik biru terhadap garis hijau
disebut _error_.

```
Gambar 5.2: Pendekatan fungsi Sigmoid.
```
Salah satu cara menghitung _error_ fungsig(x) adalah menggunakansquared
_error function_ dengan bentuk konseptual pada persamaan 5.1. Estimasi terhadap
persamaan tersebut disajikan dalam bentuk diskrit pada persamaan 5.2,
dimana (xi,yi) adalah pasangan _training data_ ( _input_ dan _desired output_ ).
Nilai _squared error_ dapat menjadi tolak ukur untuk membandingkan kinerja

(^1) Kamu patut curiga apabila model pembelajaran mesinmu memberikan kinerja
100%

```
5.1 Curve Fitting dan Error Function 63
```
suatu _learning machine_ ( _model_ ). Secara umum, bila nilainya tinggi, maka kinerja
dianggap relatif buruk; sebaliknya bila rendah, kinerja dianggap relatif
baik. Hal ini sesuai dengan konsep _intelligent agent_ [5].

```
E(g) =
```
#### ∫ ∫

```
‖y−g(x)‖^2 q(x,y)dx dy (5.1)
```
```
E(g) =
```
#### 1

#### N

#### ∑N

```
i=1
```
```
‖yi−g(xi)‖^2 (5.2)
```
Secara konseptual, bentuk fungsi regresi dilambangkan sebagai persamaan
5.3 [9].

```
g(x) =
```
#### ∫

```
y q(y|x)dy (5.3)
```
Persamaan 5.3 dibaca sebagai “ _expectation of_ y, _with the distribution of_ q.”
Secara statistik, regresi dapat disebut sebagai ekspektasi untukyberdasarkan/
dengan _input x_. Perlu diperhatikan kembali, regresi adalah pendekatan sehingga
belum tentu 100% benar (hal ini juga berlaku pada modelmachine
_learning_ pada umumnya).
Kami telah memberikan contoh fungsi linear sederhana, yaitug(x) =
xw+b. Pada kenyataannya, permasalahan kita lebih dari persoalan skalar.
Untukx( _input_ ) yang merupakan vektor, biasanya kita mengestimasi dengan
lebih banyak variable, seperti pada persamaan 5.4. Persamaan tersebut dapat
ditulis kembali dalam bentuk aljabar linear sebagai persamaan 5.5.

```
g(x) =x 1 w 1 +x 2 w 2 +···+xNwN+b (5.4)
```
g(x) =x·w+b (5.5)
Bentuk persamaan 5.4 dan 5.5 relatif _interpretable_ karena setiap fitur
pada _input_ (xi) berkorespondensi hanya dengan satu parameter bobotwi.
Artinya, kita bisa menginterpretasikan seberapa besar/kecil pengaruh suatu
fiturxiterhadap keputusan ( _output_ ) berdasarkan nilaiwi. Hal ini berbeda
dengan algoritma non-linear (misal _artificial neural network_, bab 11) dimana
satu fitur pada _input_ bisa berkorespondensi dengan banyak parameter bobot.
Perlu kamu ingat, model yang dihasilkan oleh fungsi linear lebih mudah dimengerti
dibanding fungsi non-linear. Semakin suatu model pembelajaran
mesin berbentuk non-linear, maka ia semakin susah dipahami.
Ingat kembali bab 1, _learning machine_ yang direpresentasikan dengan
fungsigbisa diatur kinerjanya dengan parameter _training_ w. _Squared error_
untuk _learning machine_ dengan parameter _training_ wdiberikan oleh persamaan
5.2, dimana (xi,yi) adalah pasangan _input-desired output_. Selain untuk
menghitung _squared error_ pada _training data_, persamaan 5.2 juga dapat
digunakan untuk menghitung _squared error_ pada _test data_. Tujuan dari regresi/machine
_learning_ secara umum adalah untuk meminimalkan nilai _loss_

64 5 Model Linear

baik pada _training_ maupun _unseen instances_. Misal, menggunakan _error function_ sebagai _proxy_ untuk _loss_.
Selain _error function_, ada banyak fungsi lainnya
seperti _Hinge_, _Log Loss_, _Cross-entropy loss_, _Ranking loss_ [1].


### 13.7 Transfer Learning

Walau konsep _transfer learning_ (TL) tidak terbatas pada _neural network_,
subbab ini membahas pemanfaatan TL paling umum pada _neural network_.
Pembaca dipersilahkan mengeksplorasi lebih lanjut.
Bayangkan kondisi berikut. Ada dua orang, Haryanto dan Wira. Saat
masih kecil, Wira pernah belajar cara memainkan Ukulele, sedangkan Haryanto
tidak. Ketika kedua orang tersebut belajar memainkan gitar, menurutmu
siapa yang bisa menguasai gitar lebih cepat?
Pada TL, kita ingin menggunakan suatu pengetahun ( _knowledge_ ) pada suatu _task_ T
1 , untuk menyelesaikan permasalahan _task_ T 2 [93, 94]. Kita memiliki
asumsi bahwaT 1 memiliki kaitan denganT 2 , sedemikian sehingga fasih pada
T 1 akan menyebabkan kita fasih padaT 2 (atau lebih fasih dibandingan tidak
menguasaiT 1 sama sekali). Perhatikan Gambar 13.27 yang mengilustrasikan
perbedaan pembelajaran mesin biasa dan penggunaan TL. Pada pembelajaran
mesin biasa, kita melatih model untuk masing-masing _task_. Pada TL,
kita menggunakan model yang sudah ada, disebut _pretrained model_, untuk
_task_ baru. Selain dimotivasi oleh kemiripan kedua _tasks_, TL juga dimotivasi
oleh ketersediaan data. Misal dataset untuk _task_ T 1 banyak, sedangkan untuk _task_ T
2 sedikit. BerhubungT 1 danT 2 memiliki kemiripan, model untuk

```
13.7 Transfer Learning 205
```
T 1 yang diadaptasi untukT 2 akan konvergen lebih cepat dibanding melatih
_model_  dari awal untukT 2.

Gambar 13.27: Pembelajaran mesin tradisional vs. menggunakantransfer
_learning_.

```
Gambar 13.28: Proses _transfer learning_.
```
Proses mengadaptasi suatu _pretrained model_ disebut _finetuning_ (Gambar
13.28). Pertama-tama kita ganti _layer terakhir_ ( _prediction layer_ ) pada
_pretrained model_ menggunakan _layer_ baru yang diinisialisasi secara _random_.^20
Kemudian, kita latih kembali model yang sudah ada menggunakan data untuk
T 2.
Secara umum, ada tiga cara untuk melakukan _finetuning_.
1.Freeze some layers. Kita _freeze_ beberapa _layer_ (parameternya tidak
diperbaharui saat fine _tuning_ ), kemudian latih _layer_ lainnya. Ilustrasi
diberikan pada Gambar 13.29.
2.Train only new last layer. Kita _freeze_ semua _layer_, kecuali _layer_ terakhir
untuk taskT 2. Ilustrasi diberikan pada Gambar 13.30
3.Train all layers. Setelah menggantu _layer terakhir_, kita latih semua _layer_
untuk taskT 2. Ilustrasi diberikan pada Gambar 13.31.

(^20) Penulis rasa, hal ini hampir wajib hukumnya

206 13 Arsitektur Neural Network

```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Retrain Layer 1
```
```
Pretrained Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_  A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Freeze
```
```
Train
```
```
Train
```
```
Gambar 13.29:Freeze some layers.
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_  A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Freeze
```
```
Train
```
```
Gambar 13.30:Train only new last layer.
```
```
Pretrained Layer 1
```
```
Pretrained Layer 2
```
```
Prediction Layer
( _softmax_ )
```
```
Retrain Layer 1
```
```
Retrain Layer 2
```
```
New Prediction Layer
( _softmax_ )
```
```
_Dataset_  A for task 𝑇! Dataset B for task 𝑇"
Adaptation
(Fine _tuning_ )
```
```
Train
```
```
Gambar 13.31:Train all layers.
```
Selain alasan yang sudah disebutkan, TL juga digunakan untuk mempercepat _training_.
Konon _pre-trained_ model pada umumnya membutuhkan
waktu _training_ yang lebih cepat (lebih sedikit iterasi) dibanding melatih model
baru. Dengan demikian, kita dapat menghemat listrik dan mengurangi polusi
CO 2. TL juga berkaitan erat dengan _successive learning_ (bab 11), dimana

```
13.8 Multi- _task_ Learning 207
```
kita melatih arsitektur lebih kecil kemudian menggunakannya pada arsitektur
yang lebih besar.
Demikian konsep paling dasar TL. Selebihkan, penulis menya _rank_ an untuk
membaca _paper_ atau tutorial terkait, seperti dibawah berikut.

- https://www.cs.uic.edu/ liub/Lifelong- _Learning_ -tutorial-slides.pdf
- https://www.aclweb.org/anthology/attachments/
    N19-5004.Presentation.pdf


### 13.3 Part-of-speech Tagging Revisited

Pada bab sebelumnya, kamu telah mempelajari konsep dasar _recurrent_ neural
_network_. Selain digunakan untuk klasifikasi (i.e., _hidden state_ terakhir digunakan
sebagai _input_ klasifikasi), RNN juga dapat digunakan untuk memprediksi
sekuens seperti persoalan _part-of-speech tagging_ (POS _tagging_ ) [82,
83, 84]. Kami harap kamu masih ingat materi bab 8 yang membahas apa itu
persoalan POS _tagging_.
Diberikan sebuah sekuens katax = {x 1 ,···,xT}, kita ingin mencari
sekuens _output_ y={y 1 ,···,yT}( _sequence prediction_ ); dimanayiadalah kelas
kata untukxi. Perhatikan, panjang _input_ dan _output_ adalah sama. Ingat
kembali bahwa pada persoalan POS _tagging_, kita ingin memprediksi suatu
kelas kata yang cocokyidari kumpulan kemungkinan kelas kataC ketika
diberikan sebuah _history_ seperti diilustrasikan oleh persamaan 13.5, dimana
_time_ lambangkan kandidat POStagke-i. Pada kasus ini, biasanya yang dicari
tahu setiap langkah ( _unfolding_ ) adalah probabilitas untuk memilih suatu
kelas katat∈Csebagai kelas kata yang cocok untuk di- _assign_ sebagaiyi.
Ilustrasi diberikan oleh Gambar. 13.14.

```
y 1 ,···,yT= arg max
t 1 ,···,tT;ti∈C
```
```
P(t 1 ,···,tT|x 1 ,···,xT) (13.5)
```
Apabila kita melihat secara sederhana ( _markov assumption_ ), hal ini tidak
lain dan tidak bukan adalah melakukan klasifikasi untuk setiap _instance_ pada
sekuens _input_ (persamaan 13.6). Pada setiap time step, kita ingin menghasilkan _output_ yang
bersesuaian.

```
yi= arg max
ti∈C
```
```
P(ti|xi) (13.6)
```
Akan tetapi, seperti yang sudah dibahas sebelum sebelumnya, _markov assumption_ memiliki
kelemahan. Kelemahan utama adalah tidak menggunakan

192 13 Arsitektur Neural Network

```
Gambar 13.14: POS _tagging_ menggunakan Recurrent Neural Network.
```
keseluruhan _history_. Persoalan ini cocok untuk diselesaikan oleh RNN karena
kemampuannya untuk mengingat seluruh sekuens (berbeda dengan _hidden_
markov model(HMM) yang menggunakan _markov assumption_ ). Secara teoritis
(dan juga praktis–sejauh yang penulis ketahui.) Pada banyak persoalan,
RNN menghasilkan performa yang lebih baik dibanding HMM. Tetapi hal ini
bergantung juga pada variasi arsitektur. Dengan ini, persoalan POS _tagging_
( _full history_ ) diilustrasikan oleh persamaan 13.7.

```
yi= arg max
ti∈C
```
```
P(ti|x 1 ,···,xT) (13.7)
```
Gambar 13.15:Sequence predictionmenggunakan Recurrent Neural Network.

Pada bab sebelumnya, kamu diberikan contoh persoalan RNN untuk satu
_output_ ; i.e., diberikan sekuens _input_, _output_ -nya hanyalah satu kelas yang
mengkategorikan seluruh sekuens _input_. Untuk persoalan POS _tagging_, kita
harus sedikit memodifikasi RNN untuk menghasilkan _output_ bagi setiap elemen
sekuens _input_. Hal ini dilakukan dengan cara melewatkan setiap _hidden_
_layer_ pada RNN pada suatu jaringan (anggap sebuah MLP+ _softmax_ ).

```
13.3 Part-of-speech Tagging Revisited 193
```
Gambar 13.16:Sequence predictionmenggunakan RNN (disederhakan) [1].
Persegi berwarna merah umumnya melambangkan _multi-layer perceptron_.

Kita lakukan prediksi kelas kata untuk setiap elemen sekuens _input_, kemudian
menghitung _loss_ untuk masing-masing elemen. Seluruh _loss_ dijumlahkan
untuk menghitung _backpropagation_ pada RNN. Ilustrasi dapat dilihat pada
Gambar. 13.15. Tidak hanya untuk persoalan POS _tagging_, arsitektur ini dapat
juga digunakan pada persoalan _sequence prediction_ lainnya sepertinamed
entity recognition.^10 Gambar. 13.15 mungkin agak sulit untuk dilihat, kami
beri bentuk lebih sederhananya (konseptual) pada Gambar. 13.16. Pada setiap
langkah, kita menentukan POStagyang sesuai dan menghitung _loss_ yang kemudian
digabungkan. _Backpropagation_ dilakukan dengan mempertimbangkan
keseluruhan (jumlah) _loss_ masing-masing prediksi.

Gambar 13.17:Sequence prediction menggunakan Recurrent Neural Network
(disederhakan), dimana prediksi saat waktu ke-tdipengaruhi oleh hasil
prediksi pada waktut−1.

Berdasarkan arsitektur yang sudah dijelaskan sebelumnya, prediksi POS
tagke-ibersifat independen dari POStaglainnya. Padahal, POStaglain-

(^10) https://en.wikipedia.org/wiki/Named-entity_recognition

194 13 Arsitektur Neural Network

nya memiliki pengaruh saat memutuskan POStagke-i(ingat kembali materi
bab 8); sebagai persamaan 13.8.

```
yi= arg max
ti∈C
```
```
P(ti|y 1 ,···,yi− 1 ,x 1 ,···,xi) (13.8)
```
Salah satu st _rate_ gi untuk menangani hal tersebut adalah dengan melewatkan
POStagpada sebuah RNN juga, seperti para persamaan 13.9 [1] (ilustrasi
pada Gambar. 13.17). Untuk mencari keseluruhan sekuens terbaik, kita
dapat menggunakan teknik _beam search_ (detil penggunaan dijelaskan pada
subbab berikutnya). RNNxpada persamaan 13.9 juga lebih intuitif apabila
diganti menggunakan _bidirectional RNN_ (dijelaskan pada subbab berikutnya).

```
P(ti|y 1 ,···,yi− 1 ,x 1 ,···,xi) =
_softmax_ (MLP([RNNx(x 1 ,···,xi); RNNtag(t 1 ,···,ti− 1 )]))
```
#### (13.9)


### Soal Latihan

13.1. POS _tagging_
Pada subbab 13.3, disebutkan bahwa _bidirectional recurrent neural network_
lebih cocok untuk persoalan POS _tagging_. Jelaskan mengapa! (hint pada
bab 8)

13.2. Eksplorasi
Jelaskanlah pada teman-temanmu apa dan bagaimana prinsip kerja:

(a) _Boltzman Machine_
(b) _Restricted Boltzman Machine_
(c) _Generative Adversarial Network_


### 13.6 Architecture Ablation

Pada bab 9, kamu telah mempelajari _feature ablation_, yaitu memilih-milih
elemen pada _input_ (untuk dibuang), sehingga model memiliki kinerja optimal.
Pada _neural network_, proses _feature engineering_ mungkin tidak sepenting
pada model- _model_ yang sudah kamu pelajari sebelumnya (e.g., model linear)
karena ia dapat me _model_ kan interaksi yang kompleks dari seluruh elemen
_input_. Pada _neural network_, masalah yang muncul adalah memilih arsitektur
yang tepat. Untuk menyederhanakan pencarian arsitektur, pada umumnya
kita dapat mengganggap sebuah _neural network_ tersusun atas beberapa

(^18) https:// _deep_ _learning_ 4j.org/restrictedboltzmannmachine
(^19) https:// _deep_ _learning_ 4j.org/ _generative_ -adversarial- _network_

204 13 Arsitektur Neural Network

“modul”. Pembagian _neural network_ menjadi modul adalah hal yang relatif.
Untuk mencari tahu konfigurasi arsitektur yang memberikan performa maksimal,
kita dapat melakukan _architecture ablation_. Idenya mirip denganfeature
ablation, dimana kita mencoba mengganti-ganti bagian (modul) neural network.
Sebagai contoh, ingat kembali arsitektur _sequence to sequence_ dimana
kita memiliki _encoder_ dan _decoder_. Kita dapat menggunakan RNN, Bidirectional
RNN, ataupun Stacked RNN sebagai _encoder_. Hal ini adalah salah satu
contoh _architecture ablation_. Akan tetapi, bisa jadi kita mengasumsikan modul
yang lebih kecil. Sebagai contoh, menggunakan RNN _encoder_ padasequence
to sequencedan kita coba mengganti-ganti fungsi aktivasi.
_Architecture ablation_ ini bisa menjadi semakin rumit tergantung persepsi
kita tentang definisi modul pada _neural network_, seperti sampai menentukan
jumlah _hidden layers_ dan berapa jumlah unit pada masing-masing _layer_. Contoh
lain adalah memilih fungsi aktivasi yang cocok untuk setiap _hidden layer_.
Pada kasus ini “modul” kita adalah sebuah _layer_. Walaupun _neural network_
memberikan kita kemudahan dari segi pemilihan fitur, kita memiliki kesulitan
dalam menentukan arsitektur. Terlebih lagi, alasan pemilihan banyaknya _units_
pada suatu _layer_ (e.g., 512 dibanding 256 _units_ ) mungkin tidak dapat dijustifikasi
dengan akurat. Pada _feature ablation_, kita dapat menjustifikasi alasan
untuk menghilangkan suatu fitur. Pada _neural network_, kita susah menjelaskan
alasan pemilihan arsitektur (dan konfigurasi parameter) karenasearch
_space_ -nya jauh lebih besar.


### 13.8 Multi- _task_ Learning

Subbab ini akan menjelaskan _framework_ melatih model pembelajaran mesin
menggunakan _multi-task learning_ (MTL). Walaupun konsep MTL tidak terbatas
pada _neural network_, bab ini membahas konsep tersebut menggunakan
arsitektur _neural network_ sebagai contoh (karena itu dimasukkan ke dalam
bab ini). Kami hanya memberikan penjelasan paling inti MTL menggunakan
contoh yang sederhana.
Pada MTL, kita melatih model untuk mengerjakan beberapa hal yang
mirip atau berkaitan, secara bersamaan. Misalnya, melatih model POS _tagging_
dan _named-entity recognition_ [95], mesin penerjemah untuk beberapa pasangan
bahasa [96], klasifikasi teks [97] dan _discourse parsing_ [98]. Karena model
dilatih untuk beberapa permasalahan yang mirip (sejenis), kita berharap agar
_model_  mampu mendapatkan “intuisi” dasar yang dapat digunakan untuk
menyelesaikan semua permasalahan. Perbedaan TL (dalam konteks pembahasan
sebelumnya) dan MTL terletak pada _timing_ pelatihan. Apabila pada
TL, model untuk _task_ T 1 danT 2 dilatih pada waktu yang berbeda, sedangkan
untuk MTL, dilatih bersamaan.
Perhatikan Gambar 13.32 yang merupakan ilustrasi permasalahan POS
_tagging_. Diberikan _input_ sekuens katax, kita ingin mencari sekuenstagy
terbaik untuk melambangkan kelas tiap kata. Kami harap kamu masih ingat
definisi permasalahan tersebut karena sudah dibahas pada bab-bab sebelumnya.
Kita ingin me _model_ kan _conditional probability_ p(y|x,θ). POS _tagging_
adalah salah satu _sequence tagging task_, dimana setiap elemen _input_ berkorespondensi
dengan elemen _output_. Kita dapat melatih model BiRNN ditambah
dengan MLP untuk melakukan prediksi kelas kata. Sebelumnya, telah
dijelaskan bahwa BiRNN mungkin lebih intuitif untuk POS _tagging_ dibanding
RNN biasa. Hal ini karena kita dapat me _model_ kan “konteks” kata (surrounding
_word_ s) dengan lebih baik, yaitu informasi dari kata sebelum dan sesudah
(BiRNN), dibanding hanya mendapat informasi dari kata sebelum (RNN).
Sekarang kamu perhatikan Gambar 13.33 yang mengilustrasikannamed
entity recognition task(NER). _Named entity_ secara sederhana adalah objek
yang bernama, misal lokasi geografis, nama perusahaan, dan nama orang.
Pada NER, kita ingin mengekstrasi _named entity_ yang ada pada _input_. _Task_
ini biasanya direpresentasikan dengan BIO _coding scheme_. Artinya, _output_

208 13 Arsitektur Neural Network

```
Gambar 13.32: POStagger.
```
untuk NER adalah pilihan B ( _begin_ ), I ( _inside_ ) dan O ( _outside_ ). Apabila suatu
kata adalah kata pertama dari suatu _named entity_, kita mengasosiasikannya
dengan _output_ B. Apabila suatu kata adalah bagian dari _named entity_, tetapi
bukan kata pertama, maka diasosiasikan dengan _output_ I. Selain keduanya,
diasosiasikan dengan _output_ O. Seperti POS _tagging_, NER juga merupakan
_sequence tagging_ karena kita ingin me _model_ kanp(y|x,θ) untukxadalah
_input_ danyadalah _output_ (BIO).

```
Gambar 13.33: _Named Entity Recognition_.
```
POS _tagging_ dan NER dianggap sebagai _task_ yang “mirip” karena keduanya
memiliki cara penyelesaian masalah yang mirip. Selain dapat diselesaikan
dengan cara yang mirip, kedua _task_ tersebut memiliki _nature_ yang sama. Dengan
alasan ini, kita dapat melatih model untuk POS _tagging_ dan NER dengan
kerangka _multi-task learning_. Akan tetapi, menentukan apakah dua _task_
memiliki _nature_ yang mirip ibarat sebuah seni (butuh _sense_ ) dibandinghard
science[1].

Gambar 13.34: _Multi-task Learning_ untuk POS _tagging_ danNamed Entity
Recognition.

```
13.8 Multi- _task_ Learning 209
```
Ide utama MTL adalah melatih _shared representation_. Sebagai ilustrasi,
perhatikan Gambar 13.34. Sebelumnya, kita melatih dua model dengan
BiRNN yang dilewatkan pada MLP. Pada saat ini, kita melatih BiRNN yang
dianggap sebagai _shared representation_. BiRNN diharapkan memiliki “intuisi”
untuk menyelesaikan kedua permasalahan, berhubung keduanya memiliki _nature_ yang
sama. Setiap _hidden layer_ pada BiRNN dilewatkan pada MLP untuk
melakukan prediksi pada masing-masing _task_. Tujuan utama MTL adalah untuk
meningkatkan kinerja. Kita melatih model untuk _task_ Xdengan meminjam
“intuisi” penyelesaikan dari _task_ Ydengan harapan “intuisi” yang dibawa
dari _task_ Y dapat memberikan informasi tambahan untuk penyelesaian _task_
X.

```
Gambar 13.35: _Multi-task Learning_ pada mesin translasi.
```
Perhatikan contoh berikutnya tentang MTL pada mesin translasi (Gambar
13.35). Pada permasalahan mesin translasi, kita melatih model menggunakan
_data_  paralel kombinasi pasangan bahasaX-Y.
Penggunaan MTL pada mesin mesin translasi pada umumnya dimotivasi
oleh dua alasan.

- Pada kombinasi pasangan bahasa tertentu, tersedia _dataset_ dengan jum-
    lah yang banyak. Tetapi, bisa jadi kita hanya memiliki _dataset_ berukuran
    kecil untuk bahasa tertentu. Sebagai contoh, data mesin translasi untuk
    pasangan English-France lebih besar dibanding English-Indonesia. Karena
    kedua kombinasi pasangan bahasa memiliki _nature_ yang cukup sama,
    kita dapat menggunakan MTL sebagai kompensasi data English-Indonesia

210 13 Arsitektur Neural Network

```
yang sedikit agar model pembelajaran bisa konvergen. Dalam artian, _encoder_ yang
dilatih menggunakan sedikit data kemungkinan memiliki performa
yang kurang baik. Dengan ini, kita latih suatu _encoder_ menggunakan
_data_  English-France dan English-Indonesia agar model bisa konvergen.
Pada kasus ini, transfer learning juga dapat digunakan. Kita melatih
_model_  English-France, kemudian memasangkan _encoder_ yang sudah dilatih
dengan _decoder_ baru untuk bahasa Indonesia.
```
- Seperti yang sudah dijelaskan sebelumnya, kita ingin menggunakan “in-
    tuisi” penyelesaian suatu permasalahan untuk permasalahan lainnya,
    berhubung solusinya keduanya mirip. Dengan hal ini, kita harap kita
    mampu meningkatkan kinerja model. Sebagai contoh, kombinasi pasangan
    bahasa English-Japanese dan English-Korean, berhubung kedua bahasa
    target memiliki struktur yang mirip.
Pada kerangka MTL, _utility function_ atau objektif _training_ adalah meminimalkanjoint
_loss_ semua _tasks_ (hal ini juga membedakan TL dan MTL),
diberikan pada persamaan 13.19. Kita dapat mendefinisikan _loss_ pada kerangka
MTL sebagai penjumlahan _loss_ pada masing-masing _task_, seperti pada persamaan
13.20. Apabila kita mengganggap suatu _task_ lebih penting dari _task_
lainnya, kita dapat menggunakan _weighted sum_, seperti pada persamaan 13.21.
Kita juga dapat menggunakan _dynamic weighting_ untuk memperhitungkan
_uncertainty_  pada tiap _task_, seperti pada persamaan 13.22 [99], dimanaσ
melambangkan varians _task-specific loss_.

```
LMTL=q(LT 1 ,...LTD) (13.19)
```
```
q(LT 1 ,...LTD) =
```
#### ∑D

```
i
```
```
LTi (13.20)
```
```
q(LT 1 ,...LTD) =
```
#### ∑D

```
i
```
```
αiLTi (13.21)
```
```
q(LTi,...LTD) =
```
#### ∑D

```
i
```
#### 1

```
2 σ^2 i
```
```
LTi+ ln(σi) (13.22)
```
Saat melatih MTL, tujuan _training_ dapat mempengaruhi proses penyajian
_data_. Seumpama saat melatih mesin translasi untuk English-{Chinese,
Japanese, Korean}, kita ingin menganggap English-Korean sebagai _main task_
sementara sisanya sebagai _supporting task_, kita dapat melakukan _pre-training_
menggunakan data English-Chinese dan English-Japanese terlebih dahulu,
diikuti oleh English-Korean (tetapi _loss_ tetap _joint loss_ ). Pada kasus ini,
penggunaan _joint weighted loss_ dapat dijustifikasi. Di lain pihak, apabila kita
mengganggap semua _tasks_ penting, kita dapat melakukan data _shuffling_ sehingga
urutan _training data_ tidak bias pa _data_ sk tertentu. Pada kasus ini,

```
13.8 Multi- _task_ Learning 211
```
```
Gambar 13.36: _Multi-task Learning_ setup.
```
penggunaan _joint loss_ –sumdapat dijustifikasi. Ilustrasi diberikan pada Gambar
13.36.


### 13.2 Recurrent Neural Network

Ide dasar _recurrent neural network_ (RNN) adalah membuat topologi jaringan
yang mampu merepresentasikan data _sequential_ (sekuensial) atau _time series_ [77],
misalkan data ramalan cuaca. Cuaca hari ini bergantung kurang
lebih pada cuaca hari sebelumnya. Sebagai contoh apabila hari sebelumnya

(^4) mathworks.com

```
13.2 Recurrent Neural Network 187
```
mendung, ada kemungkinan hari ini hujan.^5 Walau ada yang menganggap
sifat data sekuensial dan _time series_ berbeda, RNN berfokus sifat data dimana _instance_ waktu
sebelumnya (t−1) mempengaruhi _instance_ pada waktu
berikutnya (t). Intinya, mampu mengingat _history_.
Secara lebih umum, diberikan sebuah sekuens _input x_ = (x 1 ,···,xT).
Dataxt(e.g., vektor, gambar, teks, suara) dipengaruhi oleh data sebelumsebelumnya
( _history_ ), ditulis sebagaiP(xt | {x 1 ,···,xt− 1 }). Kami harap
kamu ingat kembali materi _markov assumption_ yang diberikan pada bab 8.
Pada _markov assumption_, diasumsikan bahwa dataxt( _data point_ ) hanya
dipengaruhi olehbeberapa data sebelumnya saja(analogi: _windowing_ ).
Setidaknya, asumsi ini memiliki dua masalah:

1. Menentukan _window_ terbaik. Bagaimana cara menentukan banyaknya
    data sebelumnya (secara optimal) yang mempengaruhi data sekarang.
2. Apabila kita menggunakan _markov assumption_, artinya kita mengganggap
    informasi yang dimuat oleh data lama dapat direpresentasikan oleh data
    lebih baru, i.e.,xtjuga memuat informasixt−J,...,xt− 1 ;Jadalah ukuran
    window. Penyederhanaan ini tidak jarang mengakibatkan informasi yang
    hilang.
RNN adalah salah satu bentuk arsitektur ANN untuk mengatasi masalah
yang ada pada _markov assumption_. Ide utamanya adalah memorisasi,^6 kita
ingin mengingatkeseluruhansekuens (dibanding _markov assumption_ yang
mengingat sekuens secara terbatas), implikasinya adalah RNN yang mampu
mengenali dependensi yang panjang (misalxtternyata dependen terhadap
x 1 ). RNN paling sederhana diilustrasikan pada Gambar. 13.9. Ide utamanya
adalah terdapat _pointer_ ke dirinya sendiri.

Gambar 13.9: Bentuk konseptual paling sederhana Recurrent Neural Network.

Ilustrasi Gambar. 13.9 mungkin sedikit susah dipahami karena berbentuk
sangat konseptual. Bentuk lebih matematis diilustrasikan pada Gam-

(^5) Mohon bertanya pada ahli meteorologi untuk kebenaran contoh ini. Contoh ini
semata-mata pengalaman pribadi penulis.
(^6) Tidak merujuk hal yang sama dengan _dynamic programming_.

188 13 Arsitektur Neural Network

bar. 13.10 [77]. Perhitungan _hidden state_ pada waktu ke-tbergantung pada
_input_ pada waktu ke-t(xt) dan _hidden state_ pada waktu sebelumnya (ht− 1 ).

```
Gambar 13.10: Konsep Recurrent Neural Network.
```
Konsep ini sesuai dengan prinsip _recurrent_ yaitumengingat(memorisasi)
kejadian sebelumnya. Kita dapat tulis kembali RNN sebagai persamaan 13.1.

```
ht=f(xt,ht− 1 ,b) (13.1)
```
dimanafadalah fungsi aktivasi (non-linear, dapat diturunkan). Demi menyederhanakan
penjelasan, penulis tidak mengikutsertakan _bias_ (b) pada fungsifungsi
berikutnya. Kami berharap pembaca selalu mengingat bahwa bias
adalah parameter yang diikutsertakan pada fungsi _artificial neural network_.
Fungsifdapat diganti dengan variasi _neural network_,^7 misal menggunakan
_long short-term memory network_ (LSTM) [78]. Buku ini hanya akan menjelaskan
konsep paling penting, silahkan eksplorasi sendiri variasi RNN.
Secara konseptual, persamaan 13.1 memiliki analogi denganfull markov
chain. Artinya, _hidden state_ pada saat ke-tbergantung pada semua _hidden_
_state_ dan _inputs_ ebelumnya.

```
ht=f(xt,ht− 1 )
=f(xt,f(xt− 1 ,ht− 2 ))
=f(xt,f(xt− 1 ,f({x 1 ,···,xt− 2 },{h 1 ,···,ht− 3 })))
```
#### (13.2)

_Training_ pada _recurrent neural network_ dapat menggunakan metode _backpropagation_.
Akan tetapi, metode tersebut kurang intuitif karena tidak mampu
mengakomodasi _training_ yang bersifat sekuensial _time series_. Untuk itu, terdapat
metode lain bernama _backpropagation through time_ [79].

(^7) https://en.wikipedia.org/wiki/Recurrent_ _neural_ _ _network_

```
13.2 Recurrent Neural Network 189
```
Gambar 13.11: Konsep _feed forward_ pada Recurrent Neural Network (RNN).
Karena RNN menerima _input_ berupa sekuens, kita memvisualisasikan proses
feed fowarddengan _unfolding_ (atauunrolling) RNN pada keseluruhan sekuens
_input_.

Sebagai contoh kita diberikan sebuah sekuensxdengan panjangTsebagai
_input_, dimanaxtmelambangkan input ke-i( _data point_ ), dapat berupa
_vektor_, gambar, teks, atau apapun. Kita melakukan _feed forward_ data tersebut
ke RNN, diilustrasikan pada Gambar. 13.11. Perlu diingat, RNN mengadopsi
prinsip _parameter sharing_ (serupa dengan _weight sharing_ pada CNN)
dimana neuron yang sama diulang-ulang saat process _feed forward_. Setelah
selesai proses _feed forward_, kita memperbaharui parameter ( _synapse weights_ )
berdasarkan propagasi _error_ ( _backpropagation_ ). Pada _backpropagation_ biasa,
kita perbaharui parameter sambil mempropagasi _error_ dari _hidden state_ ke
_hidden state_  sebelumnya. Teknik melatih RNN adalah _backpropagation_
through timeyang melakukan _unfolding_ pada _neural network_. Kita meng _update_
parameter saat kita sudah mencapai _hidden state_ paling awal. Hal
ini diilustrasikan pada Gambar. 13.12.^8 Gambar. 13.12 dapat disederhanakan
menjadi bentuk lebih abstrak (konseptual) pada Gambar. 13.13.
Kita mempropagasi _error_ dengan adanya efek darinext states of hidden
_layer_. _Synapse weights_ diperbaharui secara _large update_. _Synapse weight_
tidak diperbaharui per _layer_. Hal ini untuk merepresentasikan _neural network_ yang
mampu mengingat beberapa kejadian masa lampau dan keputusan
saat ini dipengaruhi oleh keputusan pada masa lampau juga (ingatan).
Untuk mengerti proses ini secara praktikal (dapat menuliskannya sebagai program),
penulis sa _rank_ an pembaca untuk melihat materi tentangcomputation
graph^9 dan disertasi PhD oleh Mikolov [47].
Walaupun secara konseptual RNN dapat mengingat seluruh kejadian sebelumnya,
hal tersebut sulit untuk dilakukan secara praktikal untuk sekuens
yang panjang. Hal ini lebih dikenal dengan _vanishing_ atau _exploding_ gradient
problem[63, 80, 81]. Seperti yang sudah dijelaskan, ANN dan variasi arsitekturnya
dilatih menggunakan teknik _stochastic gradient descent_ ( _gradient_ -based
optimization). Artinya, kita mengandalkan propagasi _error_ berdasarkan tu-

(^8) Prinsip ini mirip dengan _weight sharing_.
(^9) https://www.coursera.org/learn/ _neural_ - _network_ s- _deep_ - _learning_ /
lecture/4WdOY/computation-graph

190 13 Arsitektur Neural Network

```
Gambar 13.12: Konsep _backpropagation through time_ [47].
```
Gambar 13.13: Konsep _backpropagation through time_ [1]. Persegi berwarna
merah umumnya melambangkan _multi-layer perceptron_.

runan. Untuk sekuens _input_ yang panjang, tidak jarang nilai _gradient_ menjadi
sangat kecil dekat dengan 0 ( _vanishing_ ) atau sangat besar ( _exploding_ ). Ketika
pada satu _hidden state_ tertentu, gradient pada saat itu mendekati 0, maka
nilai tersebut yang dipropagasikan pada langkah berikutnya menjadi semakin
kecil. Hal serupa terjadi untuk nilai gradient yang besar.
Berdasarkan pemaparan ini, RNN adalah teknik untuk merubah suatu
sekuens _input_, dimana xt merepresentasikan data ke-t(e.g., vektor, gambar,
teks) menjadi sebuah _output_ vektory. Vektorydapat digunakan un-

```
13.3 Part-of-speech Tagging Revisited 191
```
tuk permasalahan lebih lanjut (buku ini memberikan contoh _sequence to sequence_ pada
subbab 13.4). Bentuk konseptual ini dapat dituangkan pada persamaan
13.3. Biasanya, nilaiydilewatkan kembali ke sebuah _multi-layer perceptron_ (MLP)
dan fungsi softmax untuk melakukan klasifikasi akhir (final
_output_ ) dalam bentuk probabilitas, seperti pada persamaan 13.4.

```
y= RNN(x 1 ,···,xN) (13.3)
```
_final output_  = softmax(MLP(y)) (13.4)
Perhatikan, arsitektur yang penulis deskripsikan pada subbab ini adalah
arsitektur paling dasar. Untuk arsitektur _state-of-the-art_, kamu dapat membaca _paper_ yang
berkaitan.


### 13.5 Arsitektur Lainnya

Selain arsitektur yang sudah dipaparkan, masih banyak arsitektur lain baik
bersifat generik (dapat digunakan untuk berbagai karakteristik data) maupun
spesifik (cocok untuk data dengan karakteristik tertentu atau permasalahan
tertentu) sebagai contoh, _Restricted Boltzman Machine_ ^18 danGenerative Adversarial
Network(GAN).^19 Saat buku ini ditulis, GAN dan _adversarial training_ sedang
populer.


### 13.4 Sequence to Sequence

Pertama-tama, kami ingin mendeskripsikan kerangka _conditioned generation_.
Pada kerangka ini, kita ingin memprediksi sebuah kelasyiberdasarkan
kelas yang sudah di-hasilkan sebelumnya ( _history_ yaituy 1 ,···,yi− 1 ) dan sebuahconditioning
contextc(berupa vektor).
Arsitektur yang dibahas pada subbab ini adalah variasi RNN untuk permasalahansequence
_generation_.^11 Diberikan sekuens _input_ x= (x 1 ,···,xT).
Kita ingin mencari sekuens _output_ y= (y 1 ,···,yM). Pada subbab sebelumnya,xiberkorespondensi
langsung denganyi, e.g.,yiadalah kelas kata (kategori)
untukxi. Tetapi, pada permasalahan saat ini,xitidak langsung berkorespondensi
denganyi. Setiapyidikondisikan olehseluruhsekuens _input_ x;
i.e., _conditioning context_ dan _history_ {y 1 ,···,yi− 1 }. Panjang sekuens _output_
Mtidak mesti sama dengan panjang sekuens _input_ T. Permasalahan ini masuk
ke dalam kerangka _conditioned generation_ dimana keseluruhan _input_ x
dapat direpresentasikan menjadi sebuah vektorc( _coding_ ). Vektorcini menjadi
variabel pengkondisi untuk menghasilkan _output_ y.
Pasangan _input-output_ dapat melambangkan teks bahasa X–teks bahasa Y
(translasi), teks-ringkasan, kalimat- _paraphrase_, dsb. Artinya ada sebuah _input_
dan kita ingin menghasilkan ( _generate/produce_ ) sebuah _output_ yang cocok
untuk _input_ tersebut. Hal ini dapat dicapai dengan mo _model_ kan pasangan
_input-output_  p(y|x). Umumnya, kita mengasumsikan ada kumpulan parameterθyang
mengontrol _conditional probability_, sehingga kita transformasi
_conditional probability_ menjadip(y|x,θ). _Conditional probability_ p(y|x,θ)
dapat difaktorkan sebagai persamaan 13.10. Kami harap kamu mampu membedakan
persamaan 13.10 dan persamaan 13.5 (dan 13.8) dengan jeli. Sedikit

(^11) Umumnya untuk bidang pemrosesan bahasa alami.

```
13.4 Sequence to Sequence 195
```
perbedaan pada formula menyebabkan makna yang berbeda. Objektif _training_ adalah
untuk meminimalkan _loss function_, sebagai contoh berbentuklog
_likelihood_ function diberikan pada persamaan 13.11, dimanaDmelambangkan
_training data_.^12

```
p(y|x,θ) =
```
#### ∏M

```
t=1
```
```
p(yt|{y 1 ,...,yt− 1 },x,θ), (13.10)
```
```
L(θ) =−
```
#### ∑

```
{x,y}∈D
```
```
logp(y|x,θ) (13.11)
```
Persamaan 13.10 dapat di _model_ kan dengan _encoder-decoder_ model yang
terdiri dari dua buah RNN dimana satu RNN sebagai _encoder_, satu lagi sebagai _decoder_.Neural
Network, pada kasus ini, bertindak sebagaicontrolling
parameter θ. Ilustrasi encoder- _decoder_ dapat dilihat pada Gambar. 13.18.
Gabungan RNN _encoder_ dan RNN _decoder_ ini disebut sebagai bentuksequence
to sequence. Warna biru merepresentasikan _encoder_ dan warna
merah merepresentasikan _decoder_. “<EOS>” adalah suatu simbol spesial (untuk
praktikalitas) yang menandakan bahwa sekuens _input_ telah selesai dan
saatnya berpindah ke _decoder_.

Gambar 13.18: Konsep _encoder-decoder_ [81]. “<EOS>” adalah suatu simbol
spesial ( _untuk praktikalitas_ ) yang menandakan bahwa sekuens _input_ telah
selesai dan saatnya berpindah ke _decoder_.

Sebuah _encoder_ merepresentasikan sekuens _input_ xmenjadi satu vektor
c.^13 Kemudian, _decoder_ men- _decoder_ epresentasicuntuk menghasilkan ( _generate_ )
sebuah sekuens _output_ y. Perhatikan, arsitektur kali ini berbeda dengan
arsitektur pada subbab 13.3. _Encoder-decoder_ ( _neural network_ ) bertindak
sebagai kumpulan parameterθyang mengatur _conditional probability_.
_Encoder-decoder_ juga dilatih menggunakan prinsip _gradient-based optimization_ untuk _tuning_ parameter
yang mengkondisikan _conditional probability_ [81].
Dengan ini, persamaan 13.10 sudah didefinisikan sebagai _neural network_ sebagai
persamaan 13.12. “enc” dan “dec” adalah fungsi _encoder_ dan _decoder_,
yaitu sekumpulan transformasi non-linear.

(^12) Ingat kembali materi _cross entropy_ !
(^13) Ingat kembali bab 12 untuk mengerti kenapa hal ini sangat diperlukan.

196 13 Arsitektur Neural Network

```
yt= dec({y 1 ,···,yt− 1 },enc(x),θ) (13.12)
```
Begitu model dilatih, _encoder-decoder_ akan mencari _output_ ˆyterbaik untuk
suatu inputx, dillustrasikan pada persamaan 13.13. Masing-masing komponen
_encoder-decoder_ dibahas pada subbab-subbab berikutnya. Untuk abstraksi
yang baik, penulis akan menggunakan notasi aljabar linear. Kami harap pembaca
sudah familiar dengan representasi _neural network_ menggunakan notasi
aljabar linear seperti yang dibahas pada bab 11.

```
yˆ= arg max
y
```
```
p(y|x,θ) (13.13)
```
13.4.1 Encoder

Seperti yang sudah dijelaskan, _encoder_ mengubah sekuens _input x_ menjadi
satu vektorc. Suatu data point pada sekuens _input_ xt(e.g., kata, gambar,
suara, dsb) umumnya direpresentasikan sebagai _feature vector_ et. Dengan
demikian, _encoder_ dapat direpresentasikan dengan persamaan 13.14, dimana
fadalah fungsi aktivasi non-linear;UdanWadalah matriks bobot ( _weight_
matrices–merepresentasikan _synapse weights_ ).

```
ht=f(ht− 1 ,et)
=f(ht− 1 U+etW)
```
#### (13.14)

Representasi _input_ cdihitung dengan persamaan 13.15, yaitu sebagai
_weighted sum_ dari _hidden states_ [57], dimanaqadalah fungsi aktivasi nonlinear.
Secara lebih sederhana, kita boleh langsung menggunakanhTsebagai
konteksc[81] karena kita mengasumsikanhTmengandung seluruh informasi
yang ada di _input_.

c=q({h 1 ,···,hT}) (13.15)
Walaupun disebut sebagai representasi keseluruhan sekuens _input_, informasi
awal pada _input_ yang panjang dapat hilang. Artinyacbisa saja memuat
lebih banyak informasi _input_ ujung-ujung akhir. Salah satu st _rate_ gi yang dapat
digunakan adalah dengan membalik ( _reversing_ ) sekuens _input_. Sebagai
contoh, _input_ x= (x 1 ,···,xT) dibalik menjadi (xT,···,x 1 ) agar bagian awal
(···,x 2 ,x 1 ) lebih dekat dengan _decoder_ [81]. Informasi yang berada dekat dengan _decoder_ cenderung
lebih diingat. Kami ingin pembaca mengingat bahwa
teknik ini pun tidaklah sempurna.

13.4.2 Decoder

Seperti yang sudah dijelaskan sebelumnya, encoder memproduksi sebuah
_vektor_ cyang merepresentasikan sekuens _input_. _Decoder_ menggunakan representasi
ini untuk memproduksi ( _generate_ ) sebuah sekuens output y =

```
13.4 Sequence to Sequence 197
```
(y 1 ,···,yM), disebut sebagai proses _decoding_. Mirip dengan _encoder_, kita
menggunakan RNN untuk menghasilkan _output_ seperti diilustrasikan pada
persamaan 13.16, dimanafmerepresentasikan fungsi aktivasi non-linear;H,
E, danCmerepresentasikan _weight matrices_. _Hidden state_ h′tmelambangkan
distribusi probabilitas suatu objek (e.g., POS tag, kelas kata yangberasal
dari suatu himpunan) untuk menjadi _output_ yt. Umumnya,ytadalah dalam
bentuk _feature-vector_ e′t.

```
h′t=f(h′t− 1 ,e′t− 1 ,c)
=f(h′t− 1 H+e′t− 1 E+cC)
```
#### (13.16)

Dengan penjelasan ini, mungkin pembaca berpikir Gambar. 13.18 tidak
lengkap. Kamu benar! Penulis sengaja memberikan gambar simplifikasi. Gambar
lebih lengkap (dan lebih nyata) diilustrasikan pada Gambar. 13.19.

```
Gambar 13.19: Konsep _encoder-decoder_ (full).
```
Kotak berwarna ungu dan hijau dapat disebut sebagai _lookup matrix_ atau
_lookup table_. Tugas mereka adalah mengubah _input_ xtmenjadi bentukfeature
vector-nya (e.g., _word embedding_ ) dan mengubahe′tmenjadiyt(e.g., _word_
_embedding_ menjadi kata). Komponen “ _Beam Search_ ” dijelaskan pada subbab
berikutnya.

13.4.3 Beam Search

Kita ingin mencari sekuens _output_ yang memaksimalkan nilai probabilitas
pada persamaan 13.13. Artinya, kita ingin mencari _output_ terbaik. Pada su-

198 13 Arsitektur Neural Network

atu tahapan _decoding_, kita memiliki beberapa macam kandidat objek untuk
dijadikan _output_. Kita ingin mencari sekuens objek sedemikian sehingga probabilitas
akhir sekuens objek tersebut bernilai terbesar sebagai _output_. Hal ini
dapat dilakukan dengan algoritma _Beam Search_.^14

```
beamSearch(problemSet, ruleSet, memorySize)
openMemory = new memory of size memorySize
_node_ List = problemSet.listOfNodes
_node_  = root or initial search node
add node to OpenMemory;
while( _node_ is not a goal node)
delete node from openMemory;
expand node and obtain its children, evaluate those children;
if a child node is pruned according to a rule in ruleSet, delete it;
place remaining, non-pruned children into openMemory;
if memory is full and has no room for new nodes, remove the worst
_node_, de _term_ ined by ruleSet, in openMemory;
_node_  = the least costly node in openMemory;
```
```
Gambar 13.20: _Beam Search_.^15
```
Secara sederhana, algoritma _Beam Search_ mirip dengan algoritma Viterbi
yang sudah dijelaskan pada bab 8, yaitu algoritma untuk mencari sekuens
dengan probabilitas tertinggi. Perbedaannya terletak padaheuristic. Untuk
menghemat memori komputer, algoritma _Beam Search_ melakukan ekspansi
terbatas. Artinya mencari hanya beberapa (B) kandidat objek sebagai sekuens
berikutnya, dimana beberapa kandidat objek tersebut memiliki probabilitas
P(yt|yt− 1 ) terbesar.Bdisebut sebagaibeam- _width_. Algoritma _Beam Search_
bekerja dengan prinsip yang mirip denganbest-first search(best-Bsearch)
yang sudah kamu pelajari di kuliah algoritma atau pengenalan kecerdasan
buatan.^16 Pseudo-code _Beam Search_ diberikan pada Gambar. 13.20 (direct
quotation).

13.4.4 Attention-based Mechanism

Seperti yang sudah dijelaskan sebelumnya, model _encoder-decoder_ memiliki
masalah saat diberikan sekuens yang panjang ( _vanishing_ atau _exploding_ gradient
problem). Kinerja model dibandingkan dengan panjang _input_ kurang
lebih dapat diilustrasikan pada Gambar. 13.21. Secara sederhana, kinerja
_model_  menurun seiring sekuens input bertambah panjang. Selain itu, representasicyang
dihasilkan _encoder_ harus memuat informasi keseluruhan _input_ walaupun
sulit dilakukan. Ditambah lagi, _decoder_ menggunakan representasinyacsaja
tanpa boleh melihat bagian-bagian khusus _inputs_ aat _decoding_.
Hal ini tidak sesuai dengan cara kerja manusia, misalnya pada kasus

(^14) https://en.wikipedia.org/wiki/Beam_search
(^15) https://en.wikibooks.org/wiki/Artificial_Intelligence/Search/
Heuristic_search/Beam_search
(^16) https://www.youtube.com/watch?v=j1H3jAAGlEA&t=2131s

```
13.4 Sequence to Sequence 199
```
translasi bahasa. Ketika mentranslasi bahasa, manusia melihat bolak-balik
bagian mana yang sudah ditranslasi dan bagian mana yang sekarang (difokuskan)
untuk ditranslasi. Artinya, manusia berfokus pada suatu bagian
_input_ untuk menghasilkan suatu translasi.

```
Gambar 13.21: Permasalahan _input_ yang panjang.
```
Sudah dijelaskan sebelumnya bahwa representasi sekuens _input_ cadalah
sebuah _weighted sum_.cyang sama digunakan sebagai _input_ bagi _decoder_ untuk
menentukan semua _output_. Akan tetapi, untuk suatu tahapan _decoding_
(untuk _hidden state_ h′ttertentu), kita mungkin ingin model lebih berfokus
pada bagian _input_ tertentu daripada _weighted sum_ yang sifatnya generik. Ide
ini adalah hal yang mendasari _attention mechanism_ [57, 58]. Ide ini sangat
berguna pada banyak aplikasi pemrosesan bahasa alami. _Attention mechanism_ dapat
dikatakan sebagai suatu _soft alignment_ antara _input_ dan _output_.
Mekanisme ini dapat membantu mengatasi permasalahan _input_ yang panjang,
seperti diilustrasikan pada Gambar. 13.22.
Dengan menggunakan _attention mechanism_, kita dapat mentransformasi
persamaan 13.16 pada _decoder_ menjadi persamaan 13.17, dimanaktmerepresentasikan
seberapa ( _how much_ ) _decoder_ harus memfokuskan diri ke _hidden_
_state_ tertentu pada _encoder_ untuk menghasilkan _output_ saat ke-t.ktdapat
dihitung pada persamaan 13.18, dimanaTmerepresentasikan panjang _input_,
hiadalah _hidden state_ pada _encoder_ pada saat ke-i,h′t− 1 adalah _hidden state_
pada _decoder_ saat ket−1.

```
h′t=f′(h′t− 1 ,e′t− 1 ,c,kt) (13.17)
```

200 13 Arsitektur Neural Network

```
Gambar 13.22: Menggunakan vs tidak menggunakan _attention_.
```
```
kt=
```
#### ∑T

```
i=1
```
```
αt,ihi
```
```
αt,i=
```
```
exp(hi·h′t− 1 )
∑T
z=1exp(hz·h
```
```
′
t− 1 )
```
#### (13.18)

Sejatinyaktadalah sebuah _weighted sum_. Berbeda dengancyang bernilai
sama untuk setiap tahapan _decoding_, _weight_ atau bobot (αt,i) masingmasing
_hidden state_  pada encoder berbeda-beda untuk tahapan _decoding_
yang berbeda. Perhatikan Gambar. 13.23 sebagai ilustrasi (lagi-lagi, bentuk
_encoder-decoder_ yang disederhanakan). Terdapat suatu bagian grafik yang
menunjukkan distribusi bobot pada bagian _input representation_ dan _attention_.
Distribusi bobot pada _weighted sum_ cadalah pembobotan yang bersifat
generik, yaitu berguna untuk keseluruhan (rata-rata) kasus. Masing-masing
_attention_ (semacam _layers_ emu) memiliki distribusi bobot yang berbeda pada
tiap tahapan _decoding_. Walaupun _attention mechanism_ sekalipun tidak sempurna,
ide ini adalah salah satu penemuan yang sangat penting.
Seperti yang dijelaskan pada bab 11 bahwa _neural network_ susah untuk
dimengerti. _Attention mechanism_ adalah salah satu cara untuk mengerti _neural_
_network_. Contoh yang mungkin lebih mudah dipahami diberikan pada
Gambar. 13.24 yang merupakan contoh kasus mesin translasi [57].Attention
mechanismmampu mengetahui _soft alignment_, yaitu kata mana yang harus
difokuskan saat melakukan translasi bahasa (bagian _input_ mana berbobot
lebih tinggi). Dengan kata lain, _attention mechanism_ memberi interpretasi
kata pada _output_ berkorespondensi dengan kata pada _input_ yang mana. Sebagai
informasi, menemukan cara untuk memahami (interpretasi) ANN adalah
salah satu tren riset masa kini [56].

```
13.4 Sequence to Sequence 201
```
```
𝑥!
```
```
...
```
```
𝑥"
```
```
_Input_  Representation 𝒄
⨁
```
```
Attention
```
```
⨁
Attention
```
```
⨁
Attention
```
```
⨁
```
```
<EOS>
```
```
𝑦!
```
```
𝒄
```
```
𝑦#
```
```
...
```
```
𝒄
```
```
𝑦$%! 𝑦$
```
```
Gambar 13.23: _Encoder-decoder_ with attention.
```
Gambar 13.24: _Attention mechanism_ pada translasi bahasa [57]. Warna lebih
gelap merepresentasikan bobot (fokus/ _attention_ ) lebih tinggi. Sebagai contoh,
kata “menendang” berkorespondensi paling erat dengan kata “kicks”.

13.4.5 Variasi Arsitektur Sequence to Sequence

Selain RNN, kita juga dapat menggunakan _bidirectional_ RNN (BiRNN) untuk
mengikutsertakan pengaruh baik _hidden states_ ebelum (h 1 ,···,ht− 1 ) dan
setelah (ht+1,···,hT) untuk menghitung _hidden states_ ekarang (ht) [85, 86,
87]. BiRNN menganggaphtsebagai gabungan ( _concatenation_ ) _forward_ hidden
_state_ h→t dan _backward hidden state_ h←t , ditulis sebagaiht=h→t +h←t.^17
_Forward hidden state_ dihitung seperti RNN biasa yang sudah dijelaskan pada
subbab _encoder_, yaituh→t =f(h→t− 1 ,et). _Backward hidden state_ dihitung
dengan arah terbalikh←t =f(h←t+1,et). Ilustrasi _encoder-decoder_ yang menggunakan
BiRNN dapat dilihat pada Gambar. 13.25.
Selain variasi RNN menjadi BiRNN kita dapat menggunakan _stacked RNN_
seperti pada Gambar. 13.26 dimana _output_ pada RNN pertama bertindak
sebagai _input_ pada RNN kedua. _Hidden states_ yang digunakan untuk menghasilkan
representasi _encoding_ adalah RNN pada tumpukan paling atas. Kita

(^17) Perhatikan! + disini dapat diartikan sebagai penjumlahan atau konkatenasi

202 13 Arsitektur Neural Network

Gambar 13.25: _Encoder-decoder_ dengan Bidirectional Recurrent Neural Net-
work.

juga dapat menggunakan variasi _attention mechanism_ seperti _neural_ checklist
_model_ [88] atau _graph-based attention_ [89]. Selain yang disebutkan, masih
banyak variasi lain yang ada, silahkan eksplorasi lebih lanjut sendiri.

```
Gambar 13.26: _Encoder-decoder_ denganstackedRecurrent Neural Network.
```
13.4.6 Rangkuman

_Sequence to sequence_ adalah salah satu bentuk _conditioned generation_. Artinya,
menggunakan RNN untuk menghasilkan ( _generate_ ) suatu sekuens _output_ yang
dikondisikan oleh variabel tertentu. Diktat ini memberikan contoh bagaimana
menghasilkan suatu sekuens _output_ berdasarkan sekuens _input_ ( _conditioned_

```
13.6 Architecture Ablation 203
```
on a sequence of input). Selain _input_ berupa sekuens, konsep ini juga dapat
diaplikasikan pada bentuk lainnya. Misalnya, menghasilkan _caption_ saat input
yang diberikan adalah sebuah gambar [90]. Kita ubah _encoder_ menjadi sebuah
CNN (ingat kembali subbab 13.1) dan _decoder_ berupa RNN [90]. Gabungan
CNN-RNN tersebut dilatih bersama menggunakan metode _backpropagation_.
Perhatikan, walaupun memiliki kemiripan dengan _hidden markov model_,
_sequence to sequence_ bukanlah _generative model_. Pada _generative model_, kita
ingin me _model_ kan _joint probability_ p(x,y) =p(y|x)p(x) (walaupun secara
tidak langsung, misal menggunakan teori Bayes). _Sequence to sequence_ adalah
_discriminative model_ walaupun _output_ -nya berupa sekuens, ia tidak me _model_ kanp(x),
berbeda dengan _hidden markov model_. Kita ingin me _model_ kan
_conditional probability_ p(y|x) secara langsung, seperti _classifier_ lainnya (e.g.,
_logistic regression_ ). Jadi yang di _model_ kan antara _generative_ dandiscriminative
_model_ adalah dua hal yang berbeda.
Pada subbab ini, penulis memberikan contoh _attention mechanism_ yang
beroperasi antara _encoder_ dan _decoder_. Masih banyak variasi lainnya seperti
_self-attention_, _multi-head attention_ dan _hierarchical-attention_ [91, 92]. Walaupun
motivasi dan penggunaan variasi _attention mechanism_ berbeda-beda,
konsep dasarnya sama yaitu mengekstrak (atau mengambil) informasi dari
bagian _network_ lainnya.


### 13.1 Convolutional Neural Network

Subbab ini akan memaparkanide utamadari _convolutional neural network_
(CNN) berdasarkan _paper_ asli dari LeCun dan Bengio [76] (saat buku ini
ditulis sudah ada banyak variasi). CNN memiliki banyak istilah dari bidang
pemrosesan gambar (karena dicetuskan dari bidang tersebut), tetapi demi

182 13 Arsitektur Neural Network

mempermudah pemahaman intuisi CNN, diktat ini akan menggunakan istilah
yang lebih umum juga.
Sekarang, mari kita memasuki cerita CNN dari segi pemrosesan gambar.
Objek bisa saja terlatak pada berbagai macam posisi seperti diilustrasikan
oleh Gambar. 13.1. Selain tantangan variasi posisi objek, masih ada juga tantangan
lain seperti rotasi objek dan perbedaan ukuran objek ( _scaling_ ). Kita
ingin mengenali (memproses) objek pada gambar pada berbagai macam posisi
yang mungkin ( _translation invariance_ ). Salah satu cara yang mungkin
adalah dengan membuat suatu mesin pembelajaran (ANN) untuk regional
tertentu seperti pada Gambar. 13.2 (warna biru) kemudian meng- _copy_ mesin
pembelajaran untuk mampu mengenali objek pada regional-regional lainnya.
Akan tetapi, kemungkinan besar ANN _copy_ memiliki konfigurasi parameter
yang sama dengan ANN awal. Hal tersebut disebabkan objek memiliki
informasi prediktif (predictive information– _feature vector_ ) yang sama yang
berguna untuk menganalisisnya. Dengan kata lain, objek yang sama ( _smiley_ )
memiliki pola _feature vector_ yang mirip walaupun posisinya digeser-geser.
ANN (MLP) bisa juga mempelajari prinsip _translation invariance_, tetapi
memerlukan jauh lebih banyak parameter dibanding CNN (subbab berikutnya
secara lebih matematis) yang memang didesain dengan prinsiptranslation
in _variance_ (“ _built-in_ ”).

```
Gambar 13.1: Motivasi _convolutional neural network_.
```
13.1.1 Convolution

Seperti yang sudah dijelaskan, motivasi CNN adalah untuk mampu mengenali
aspek yang informatif pada regional tertentu (lokal). Dibanding meng _copy_ mesin
pembelajaran beberapa kali untuk mengenali objek pada banyak
regional, ide lebih baik adalah untuk menggunakan _sliding window_. Setiap

```
13.1 Convolutional Neural Network 183
```
```
Gambar 13.2: Motivasi _convolutional neural network_, solusi regional.
```
operasi pada _window_ ^1 bertujuan untuk mencari aspek lokal yang paling informatif.
Ilustrasi diberikan oleh Gambar. 13.3. Warna biru merepresentasikan
satu _window_, kemudian kotak ungu merepresentasikan aspek lokal paling informatif
(disebut _filter_ ) yang dikenali oleh _window_. Dengan kata lain, kita
mentransformasi suatu _window_ menjadi suatu nilai numerik ( _filter_ ). Kita juga
dapat mentransformasi suatu _window_ (regional) menjadidnilai numerik (d _channels_,
setiap elemen berkorespondensi pada suatu _filter_ ). _Window_ ini kemudian
digeser-geser sebanyakTkali, sehingga akhirnya kita mendapatkan
_vektor_  dengan panjangd×T. Keseluruhan operasi ini disebut sebagaicon-
volution.^2

```
Gambar 13.3:Sliding window.
```
Agar kamu lebih mudah memahami prinsip ini, kami berikan contoh dalam
bentuk 1-D pada Gambar. 13.4. Warna biru merepresentasikan _feature vector_
(regional) untuk suatu _input_ (e.g., regional pada suatu gambar, kata pada
kalimat, dsb). Pada contoh ini, setiap 2 _input_ ditransformasi menjadi vektor
berdimensi 2 (2- _channels_ ); menghasilkan vektor berdimensi 4 (2 _window_ ×
2).
Pada contoh sebelumnya, kita menggunakan _window_ selebar 2, satu _window_ mencakup
2 data lokal; i.e., _window_ 1 = (x 1 ,x 2 ), _window_ 2 = (x 2 ,x 3 ), ...
; untuk suatu _input x_. Kita juga dapat mempergunakan _stride_ sebesars,

(^1) Dikenal juga sebagai _receptive field_.
(^2) Istilah _convolution_ yang diterangkan pada konteks _machine learning_ memiliki arti
yang berbeda pada bidang _signal processing_.

184 13 Arsitektur Neural Network

```
Gambar 13.4:1D Convolution.
```
yaitu seberapa banyak data yang digeser untuk _window_ baru. Contoh yang
diberikan memiliki _stride_ sebesar satu. Apabila kita memiliki _stride_ =2, maka
kita menggeser sebanyak 2 data setiap langkah; i.e., _window_ 1 = (x 1 ,x 2 ), _window_
2 = (x 3 ,x 4 ),···.
Selain _sliding window_ dan _filter_, _convolutional layer_ juga mengadopsi prinsip _weight_
sharing. Artinya, _synapse weights_ untuk suatu filter adalah sama
walau _filter_ tersebut dipergunakan untuk berbagai _window_. Sebagai ilustrasi,
perhatikan Gambar. 13.5, warna yang sama pada _synapse weights_ menunjukkansynapse
_weight_ s bersangkutan memiliki nilai ( _weight_ ) yang sama.
Tidak hanya pada _filter_ hitam, hal serupa juga terjadi pada _filter_ berwarna
oranye (i.e., _filter_ berwarnya oranye juga memenuhi prinsip _weight sharing_ ).
Walaupun memiliki konfigurasi bobot _synapse weights_ yang sama, unit dapat
menghasilkan _output_ yang berbeda untuk _input_ yang berbeda. Konsep
_weight sharing_ ini sesuai dengan cerita sebelumnya bahwa konfigurasi parameter
untuk mengenali karakteristik informatif untuk satu objek bernilai sama
walau pada lokasi yang berbeda. Dengan _weight sharing_, parameter _neural_
_network_ juga menjadi lebih sedikit dibanding menggunakan _multilayer perceptron_ ( _feed-forward_
_neural network_ ).

```
Gambar 13.5: Konsep _weight sharing_.
```
13.1.2 Pooling

Pada tahap _convolution_, kita merubah setiap _k-sized window_ menjadi satu
_vektor_  berdimensid(yang dapat disusun menjadi matriksD). Semua vektor
yang dihasilkan pada tahap sebelumnya dikombinasikan ( _pooled_ ) menjadi

```
13.1 Convolutional Neural Network 185
```
satu vektorc. Ide utamanya adalah mengekstrak informasi paling informatif
(semacam meringkas). Ada beberapa teknik _pooling_, diantaranya: _max pooling_,
_average pooling_, dan _K-max pooling_ ;^3 diilustrasikan pada Gambar. 13.6.Max
_pooling_ mencari nilai maksimum untuk setiap dimensi vektor. _Average pooling_
mencari nilai rata-rata tiap dimensi. _K-max pooling_ mencariKnilai terbesar
untuk setiap dimensinya (kemudian hasilnya digabungkan). Gabungan operasi
_convolution_ dan _pooling_ secara konseptual diilustrasikan pada Gambar. 13.7.

```
Gambar 13.6: Contoh _pooling_.
```
Setelah melewati berbagai operasi convolution dan _pooling_, kita akan
memiliki satu vektor yang kemudian dilewatkan pada _multilayer perceptron_
( _fully connected_ ) untuk melakukan sesuatu (tergantung permasalahan), misal
klasifikasi gambar, klasifikasi sen _time_ n, dsb (Ilustrasi pada Gambar. 13.8).

13.1.3 Rangkuman

Kemampuan utama _convolutional neural network_ (CNN) adalah arsitektur
yang mampu mengenali informasi prediktif suatu objek (gambar, teks, potongan
suara, dsb) walaupun objek tersebut dapat diposisikan dimana saja
pada _input_. Kontribusi CNN adalah pada _convolution_ dan _pooling_ layer. _Convolution_ bekerja
dengan prinsip _sliding window_ dan _weight sharing_ (mengurangi
kompleksitas perhitungan). _Pooling layer_ berguna untuk merangkum
informasi informatif yang dihasilkan oleh suatu _convolution_ (mengurangi dimensi).
Pada ujung akhir CNN, kita lewatkan satu vektor hasil beberapa operasi _convolution_ dan _pooling_ padamulti _layer_
_perceptron_ ( _feed-forward_ neural
_network_ ), dikenal juga sebagai _fully connected layer_, untuk melakukan suatu
pekerjaan, e.g., klasifikasi. Perhatikan, pada umumnya CNN tidak berdiri

(^3) Kami ingin pembaca mengeksplorasi sendiri _dynamic pooling_.

186 13 Arsitektur Neural Network

```
Gambar 13.7: _Convolution_ dan _pooling_.
```
```
Gambar 13.8: _Convolution_ al Neural Network.^4
```
sendiri, dalam artian CNN biasanya digunakan (dikombinasikan) pada arsitektur
yang lebih besar.


### 12.2 Singular Value Decomposition

Sebelum masuk ke _autoencoder_ secara matematis, penulis akan memberikan
sedikit _overview_ tentang dekomposisi matriks. Seperti yang sudah dijelaskan
pada bab-bab sebelumnya, dataset dimana setiap _input_ direpresentasikan oleh
_feature vector_ dapat disusun menjadi matriksXberukuranN×F, dimanaN
adalah banyaknya sampel^4 danFadalah dimensi fitur. Pada _machine learning_,
dekomposisi atau reduksi dimensi sangat penting dilakukan terutama
ketika dataset berupa _sparse matrix_. Dekomposisi berkaitan erat denganprincipal
component analysis (PCA) yang sudah kamu pelajari. Teknik PCA
(melalui _eigendecomposition_ ) mendekomposisi sebuah matriksXmenjadi tiga
buah matriks, seperti diilustrasikan pada persamaan 12.1. MatriksAadalah
kumpulan eigenvector danλadalah sebuah diagonal matriks yang berisi nilai
eigenvalue, dimanaUberukuranN×N,VberukuranN×F, danWT
berukuranF×F.
X=AλA−^1 (12.1)

PCA membutuhkan matriks yang kamu ingin dekomposisi berbentu simetris.
Sedangkan, teknik _singular value decomposition_ (SVD) tidak. Dengan konsep
yang mirip dengna PCA, matriksXdapat difaktorisasi menjadi tiga buah matriks
menggunakan teknik SVD, dimana operasi ini berkaitan dengan mencari
eigenvectors, diilustrasikan pada persamaan 12.2.

```
X=U V WT (12.2)
```
(^4) Banyaknya training data.

166 12 Auto _encoder_

Perlu diperhatikan, matriksVadalah sebuah diagonal matriks (elemennya
adalah nilai _singular value_ dariX).Udisebut _left-singular vectors_ yang
tersusun atas eigenvector dariXXT. Sementara,Wdisebutright-singular
vectorsyang tersusun atas eigenvector dariXTX.
Misalkan kita mempunyai sebuah matriks lainVˆberukuranK×K, yaitu
modifikasi matriksVdengan mengganti sejumlah elemen diagonalnya menjadi
0 (analogi seperti menghapus beberapa baris dan kolom yang dianggap kurang
penting). Sebagai contoh, perhatikan ilustrasi berikut!

#### V=

#### 

#### 

#### 

#### 

```
α 1 0 0 0 0
0 α 2 0 0 0
0 0 α 3 0 0
0 0 0 α 40
```
#### 

#### 

#### 

#### 

#### Vˆ=

#### 

#### 

```
α 1 0 0
0 α 2 0
0 0α 3
```
#### 

#### 

Kita juga dapat me-nol-kan sejumlah baris dan kolom pada matriksUdan
WmenjadiUˆ(N×K) danWˆT(K×F). Apabila kita mengalikan semuanya,
kita akan mendapat matriksXˆyang merupakan _approximation_ untuk matriks
asliX, seperti diilustrasikan pada persamaan 12.3.

Xˆ=UˆVˆWˆT (12.3)
Suatu baris dari matriksE=Uˆ Vˆ dianggap sebagai aproksimasi baris
matriksXberdimensi tinggi [1]. Artinya, menghitung _dot-product_ Ei·Ej=
Xˆi·Xˆj. Artinya, operasi pada matriksEkurang lebih melambangkan operasi
pada matriks asli. Konsep ini menjadi fundamental _autoencoder_ yang akan
dibahas pada subbab berikutnya. Operasi data pada level _coding_ dianggap
merepresentasikan operasi pada bentuk aslinya. Matriks aproksimasi ini memanfaatkan
sejumlahKarah paling berpengaruh pada data. Dengan analogi
tersebut, sama seperti mentransformasi data ke bentuk lain dimana data hasil
transformasi memiliki varians yang tinggi.


### 12.1 Representation Learning

Pada bab model linear, kamu telah mempelajari ide untuk mentransformasi
_data_  menjadi dimensi lebih tinggi agar data tersebut menjadi _linearly separable_.
Pada bab ini, kamu mempelajari hal sebaliknya, yaitu mengurangi
dimensi. _Curse of dimensionality_ dapat dipahami secara mendalam apabila
kamu membaca buku [65]. Untuk melakukan klasifikasi maupun _clustering_,
kita membutuhkan fitur. Fitur tersebut haruslah dapat membedakan satu _instance_ dan _instance_ lainnya.
Seringkali, untuk membedakan _instance_ satu dan

164 12 Auto _encoder_

_instance_ lainnya, kita membutuhkan _feature vector_ yang berdimensi relatif
“besar”. Karena dimensi _feature vector_ besar, kita butuh sumber daya komputasi
yang besar juga (bab 9). Untuk itu, terdapat metode-metodefeature
selection^1 untuk memilih fitur-fitur yang dianggap “representatif” dibanding
fitur lainnya. Sayangnya, bila kita menggunakan metode-metodefeature
selectionini, tidak jarang kita kelihangan informasi yang memuat karakteristik
_data_. Dengan kata lain, ada karakteristik yang hilang saat menggunakan
_feature selection_.
Pertanyaan yang kita ingin jawab adalah apakah ada cara untuk merepresentasikan
_data_  ke dalam bentuk yang membutuhkan memori lebih sedikit
tanpa adanya kehilangan informasi? Kita dapat memanfaatkan prinsipprincipal
component analysisyang sudah kamu pelajari pada bab 9 untuk mereduksi
dimensi data (mengurangi dimensi _input_ ), pada saat yang bersamaan,
menjaga karakteristik data. _Representation learning_ adalah metode untuk
melakukankompresi _feature vector_ menggunakan _neural network_.^2 Proses
melakukan kompresi disebut _encoding_, hasil _feature vector_ dalam bentuk
terkompres disebut _coding_, proses mengembalikan hasil kompresi ke bentuk
awal disebut _decoding_.^3 Neural networkyang mampu melakukan proses _encoding_ disebut _encoder_,
sedangkan _decoder_ untuk proses _decoding_ [66, 67,
68, 69, 70].

```
Gambar 12.1: Contoh auto _encoder_ sederhana.
```
Contoh _representation learning_ paling sederhana kemungkinan besar adalah
_autoencoder_ yaitu _neural network_ yang dapat merepresentasikan data kemudian
merekonstruksinya kembali. Ilustrasi _autoencoder_ dapat dilihat pada

(^1) [http://scikit-learn.org/stable/modules/feature_selection.html](http://scikit-learn.org/stable/modules/feature_selection.html)
(^2) Istilah _representation learning_ pada umumnya mengacu dengan teknik menggunakan _neural_
_network_.
(^3) Bisa dianggap sebagai proses menginterpretasikan _coding_.

```
12.2 Singular Value Decomposition 165
```
Gambar 12.1. Karena tujuan _encoder_ untuk kompresi, bentuk terkompresi
haruslah memiliki dimensi lebih kecil dari dimensi _input_. _Neural network_
mampu melakukan “kompresi” dengan baik karena ia mampu menemukan
_hidden structure_ dari data. _Autoencoder_ dilatih untuk memilimalkan meminimalkan _loss_.
Kamu mungkin berpikir bahwa idealnya, _output_ harus sama
dengan _input_, yaitu _autoencoder_ dengan tingkat _loss_ 0%. Akan tetapi, kita
sebenarnya tidak ingin _autoencoder_ memiliki performa 100% (subbab 12.4).
Contoh klasik lainnya adalah _N-gram language modelling_, yaitu memprediksi
kataytdiberikan suatu konteks ( _surrounding words_ ) misal kata sebelumnyayt−
1 (bigram), i.e.,P(yt|yt− 1 ) Apabila kita mempunyai _vocabulary_ sebesar
40,000 berarti suatu bigram model membutuhkan _memory_ sebesar
40, 0002 (kombinatorial). Apabila kita ingin memprediksi kata diberikan
_history_ yang lebih panjang (misal dua kata sebelumnya– _trigram_ ) maka kita
membutuhkan _memory_ sebesar 40, 0003. Artinya, _memory_ yang dibutuhkan
berlipat secara eksponensial. Tetapi, terdapat st _rate_ gi menggunakan _neural_
_network_ dimana parameter yang dibutuhkan tidak berlipat secara eksponensial
walau kita ingin me _model_ kan konteks yang lebih besar [71].