Pengumuman Penting dari Jo-Pink

Halo The Next Digital Talents!

Modul Artificial Intelligence ini memang

sengaja Jo-Pink kasih full pack theory &
application dengan materi yang ‘rich’
banget.

Mengapa?
Supaya bisa tetap dipelajari setelah lulus dari program Data
Science & Artificial Intelligence Startup Campus!

Tapi ini banyak banget, gimana belajarnya?

Teman-teman bisa fokus mempelajari learning video sambil
membaca modul bagian use case atau aplikasinya ya.

Kalau ada yang tidak dipahami di learning

video, modul ini akan berperan jadi
‘ensiklopedia’ untuk mengusut tuntas
kebingunganmu.

Selamat belajar!
2
 Daftar Isi
A. Deep Learning (3)
■ Deep Learning (Basic Artificial Neural Network /ANN) (3)
■ Konsep (3)
■ Teori (4)
● Pengantar Neural Network (4)
● Activation Function bagi Input (7)
● Cost Function dan Gradient Descent (11)
● Backpropagation (16)
■ Apa itu PyTorch? (20)
● Pengantar Tensor (20)
■ Apa itu Tensorflow? (22)
■ Apa itu Keras? (22)
■ Study Case : Prediksi Jumlah Kalori Dalam Fast Food (PyTorch) (23)
■ Study Case : Prediksi Jumlah Kalori Dalam Fast Food (Tensorflow dan Keras) (29)
■ Study Case : Prediksi Kemungkinan Membeli Seseorang Berdasarkan Gender, Umur, dan
Tingkat Penghasilan (PyTorch) (36)
■ Study Case : Prediksi Kemungkinan Membeli Seseorang Berdasarkan Gender, Umur, dan
Tingkat Penghasilan (Tensorflow dan Keras) (42)
■ Recurrent Neural Network (54)
● Konsep (54)
● Teori (57)
● RNN Batches (61)
● Study Case : Prediksi Penjualan Liquor pada Iowa (PyTorch) (63)
● Study Case : Prediksi Penjualan Liquor pada Iowa (Tensorflow dan Keras) (80)
■ Autoencoder (101)
● Teori (101)
● Studi Kasus - Autoencoder untuk Data MNIST (PyTorch) (103)
● Studi Kasus - Autoencoder untuk Data MNIST (Tensorflow dan Keras) (115)
■ Kesimpulan (122)
■ Exercise (123)

3
Deep Learning (Basic Artificial Neural Network)
Kita sampai kepada bagian akhir dari pembelajaran Machine Learning, yaitu materi
mengenai Deep Learning. Deep Learning ini dibangun atas dasar menyerupai proses dan struktur
neural network yang ada pada otak manusia. Istilah “Deep” pada Deep Learning menyatakan bahwa
ada banyak neural network yang digunakan dalam proses pembelajaran. Apabila kita menggunakan
neural network sederhana ataupun proses machine learning tradisional, kita mungkin hanya
menggunakan 2 lapis layer berupa fitur yang digunakan untuk mencari tahu hasil keluaran ataupun
prediksi yang dilakukan oleh model. Apabila kita menggunakan Deep Learning, mungkin kita dapat
menggunakan lebih dari 2, atau bahkan mungkin bisa puluhan ataupun ratusan layer tersembunyi
yang digunakan untuk melakukan prediksi.

Konsep

Layer yang berdekatan dengan input, akan menerima fitur dengan pemahaman yang lebih
rendah. Sinyal yang diteruskan pada layer selanjutnya akan mempelajari fitur tersebut dan terus
mencari pemahaman yang lebih kompleks dari input tersebut.
Dalam melatih model Deep Learning, atau dapat kita sebut sebagai Deep Neural Network,
kita perlu memperhatikan dua parameter yang digunakan dalam network itu sendiri, yang dikenal
dengan weight dan juga biases, dimana kedua variabel ini digunakan untuk meminimalisir perbedaan
antara hasil prediksi pada output dan juga nilai sebenarnya. Proses ini disebut juga backpropagation,
yang mungkin akan dibahas beberapa kali pada teori dan pemahaman selanjutnya.

4
 Kita akan membahas beberapa istilah dan juga konsep dari Deep Learning ini, agar mudah
untuk dimengerti.

Teori
Sebelum kita membahas lebih jauh mengenai konsep secara teoritis mengenai Deep Learning
ini, kita perlu memahami secara garis besar, bagaimana model ini bekerja. Secara struktur, kita akan
menemui bahwa urutan pengerjaan Deep Learning ini akan mirip seperti pembahasan kita pada
metode Supervised Learning.

1. Pengantar Neural Network

Deep Learning dimulai dengan pemahaman mengenai adanya neural network, atau kita sebut
sebagai artificial neural network (ANN) yang didasari dari konsep neuron pada otak manusia.

Neuron pada otak manusia memiliki ilustrasi seperti gambar di atas. Neuron akan menerima
sebuah input berupa sinapsis, pada dendrite, yaitu ujung dari sebuah neuron. Sinyal sinapsis ini akan
dibawa melalui tubuh sel, sampai pada akhirnya disalurkan pada sinapsis output.
Berdasarkan konsep sederhana ini, kita dapat menggambarkan bahwa neuron tersebut
menerima input dari banyak sumber (X1, X2, …., Xn) yang dapat menghasilkan banyak output. Pada
pemrograman, kita dapat menyederhanakan gambar tersebut menjadi seperti berikut ini :

5
 Model neural network tersebut disebut juga sebagai perceptron. Dalam sebuah perceptron,
kita memiliki sebuah fungsi yang menggambarkan hubungan antara seluruh input Xn dengan y.
Fungsi f(x) tersebut akan mengambil input, lalu melakukan sebuah kalkulasi, lalu mengembalikan
sebuah nilai yaitu y. Apabila fungsi tersebut hanya merupakan penjumlahan, maka kita bisa
menuliskan bahwa y = x1 + x2.

Dengan fungsi f(x) tersebut, kita tidak bisa membuat perceptron tersebut untuk dapat belajar
dengan sendirinya. Kita lihat sebelumnya bahwa perceptron tersebut hanya menerima input, lalu
mengeluarkan output sesuai dengan fungsi yang sudah ditentukan. Agar perceptron tersebut dapat
belajar, kita bisa menambahkan sebuah variabel yaitu weight, yang merupakan pembobotan untuk
memberikan bobot kepada tiap variabel input yang diterima oleh neuron tersebut. Weight ini dapat
diubah - ubah sesuai dengan nilai X. Dengan pembobotan ini, kita akan mengubah persamaan fungsi
kita menjadi y = x1.w1 + x2.w2.

Coba perhatikan apabila kita memiliki nilai X sama dengan 0. Penambahan weights tidak akan
mempengaruhi fungsi sama sekali. Oleh karena itu, kita akan menambahkan sebuah variabel lagi,
yang dinamakan biases, atau nilai bias.

Nilai bias ini digunakan untuk memberikan pengaruh dari sebuah input terhadap fungsi
perceptron. Sehingga, apabila kita menemukan nilai X bernilai 0, maka kita tetap mendapatkan
sebuah nilai. Secara matematika, dengan n sebagai jumlah input, kita bisa menuliskan secara
matematika yaitu :

6
 Dengan nilai X merupakan sebuah fitur, kita dapat berasumsi bahwa X ini akan menjadi
sebuah tensor. Tensor merupakan sebutan untuk sebuah matriks dengan ukuran n-dimensi. Karena
nilai bias biasanya merupakan sebuah konstanta dan tidak terpengaruh oleh input, kita bisa mengganti
nilai bias tersebut menjadi sebuah variabel B besar yang berarti sebuah bias. Secara matematika, kita
dapat mengubah fungsi di atas menjadi seperti berikut ini.

Dimana nilai B adalah :

Dengan adanya hanya satu perceptron, kita akan sulit untuk membuat sebuah model yang
dapat men-generalisasikan nilai output. Oleh karena itu, kita akan membuat model perceptron multi-
layer, dimana kita menggabungkan banyak perceptron menjadi satu.

Konsep ini menjelaskan bahwa hasil output dari sebuah layer akan menjadi sebuah input bagi
layer selanjutnya. Kumpulan dari perceptron ini dapat kita sebut sebagai neuron, dan gambar di atas
menggambarkan sebuah kumpulan neuron yang kita sebut sebagai neural network.

Layer input
Layer output

Hidden Layer
7
 Layer input merupakan lapisan pertama yang berisikan input. Hidden layer merupakan layer
di antara input dan output. Sulit untuk menggambarkan layer ini, karena memiliki fungsi yang
kompleks dan memiliki jarak yang jauh antara input dan output. Layer output merupakan lapisan
terakhir, yang menentukan output dari model tersebut. Layer output dapat berisikan lebih dari satu
output, untuk kasus seperti klasifikasi.
Apabila didalam sebuah hidden layer memiliki banyak sekali layer di dalamnya, maka
keseluruhan model tersebut dapat disebut sebagai Deep Neural Network. Dengan menggunakan
neural network ini, kita dapat dengan mudah membuat model dengan hampir seluruh fungsi yang
dapat dibentuk.
Berdasarkan riset yang dilakukan secara matematika, neural network dapat bekerja dengan
baik pada hampir sebagian besar fungsi yang bersifat continuous. Apakah neural network tidak bisa
digunakan untuk fungsi yang bersifat diskrit?

2. Activation Function bagi Input

Pada contoh yang kita buat sebelumnya, kita menyatakan fungsi f(x) adalah fungsi
penjumlahan bagi seluruh input yang masuk. Pada kasus sebenarnya, sangat jarang sekali kita dapat
menemukan fungsi seperti ini pada kasus yang membutuhkan Deep Learning. Apabila kita
menggunakan fungsi seperti ini, semakin banyak input akan menghasilkan output yang lebih besar
lagi. Dalam sebuah klasifikasi ataupun permasalahan yang membutuhkan output diskrit, kita
memerlukan hasil output jatuh pada angka 0 dan 1, ataupun sesuai jumlah output diskrit yang kita
inginkan. Nilai ini akan memberikan kita probabilitas untuk tiap jumlah output yang dapat dihasilkan.
Oleh karena itu, kita akan mengenal yang disebut sebagai Activation Function, yang digunakan
untuk memberikan batasan kepada nilai output dari sebuah neuron.
Sesuai namanya, Activation Function adalah sebuah fungsi yang digunakan untuk
menentukan apakah sebuah neuron perlu diaktifkan atau tidak. Hal ini dapat membantu neuron untuk
menentukan apakah neuron perlu diaktifkan atau tidak, atau kita dapat menggunakan fungsi yang
lebih sederhana untuk memproses input tersebut. Perhatikan sebelumnya kita memiliki sebuah fungsi
x*w + b sebagai input. Kita bisa memasukan nilai tersebut pada sebuah variabel z sehingga menjadi
seperti ini :

8
 Untuk sebuah fungsi continuous, mungkin kita bisa menerapkan sebuah nilai threshold,
namun untuk sebuah permasalahan yang berkaitan dengan fungsi diskrit atau klasifikasi, kita perlu
sebuah fungsi yang membantu kita untuk mengaktifkan neuron kita.

Sebuah fungsi yang sangat sederhana yaitu unit-step. Perhatikan bentuknya berikut ini :

Output z = w*x + b

0
0

Fungsi tersebut berguna apabila kita ingin menyelesaikan masalah klasifikasi, namun
perubahan yang sangat kecil mungkin tidak akan sangat mempengaruhi output kita. Ingat pada materi
mengenai Logistic Regression, kita dapat menggunakan sebuah fungsi sigmoid, untuk
mencerminkan perubahan pada output kita.

Untuk sebuah fungsi continuous, mungkin kita bisa menerapkan sebuah nilai threshold,
namun untuk sebuah permasalahan yang berkaitan dengan fungsi diskrit atau klasifikasi, kita perlu
sebuah fungsi yang membantu kita untuk mengaktifkan neuron kita.
Jenis Activation Function lainnya yang sering digunakan antara lain adalah hyperbolic
tangent (tanh), karena memiliki output antara -1 sampai 1. Berikut bentuk grafiknya.

9
 Jenis Activation Function lainnya yang umum digunakan juga adalah Rectified Linear Unit
(ReLU). ReLU ini banyak digunakan karena performanya yang sangat baik apabila digunakan dengan
neural network, dan menjadi sebuah activation function default apabila kita menggunakan metode
Deep Learning nantinya. Konsep dari ReLU ini sangat sederhana, apabila digambarkan menjadi
seperti ini :

Output

z = wx + b

ReLU ini akan membuat semua input negatif menjadi 0 dan hanya mengeluarkan nilai output
yang positif. Ketika kita bicara mengenai Vanishing Gradient pada Deep Learning, ReLU ini
ternyata memiliki performa yang bagus, sehingga fungsi ini sering dijadikan default ketika membuat
sebuah neural network.
Selain ReLU kita juga mempunyai jenis activation function lain yang dapat digunakan untuk
klasifikasi lebih dari dua output. Perhatikan bahwa jenis - jenis activation function yang sebelumnya
telah disebutkan, hanya memberikan dua jenis output, dan sulit digunakan untuk menyelesaikan
masalah apabila ada lebih dari dua output. Untuk itu kita tetap masih bisa menggunakan sigmoid
function, karena dapat dilihat sebelumnya bahwa tiap input bisa memberikan kita output yang
independen.

10
 Namun, karena outputnya independen, apabila kita berbicara mengenai probabilitas yang
dihasilkan, apabila seluruhnya dijumlah, maka totalnya dapat lebih dari 1. Ingat materi pada logistic
regression dimana tiap titik input memiliki probabilitasnya masing - masing. Perhatikan gambar
berikut ini yang dikutip dari materi logistic regression.

p = 0.95
p = 0.88
p = 0.9
p = 0.83

p = 0.65

1 - p = 0.7 p = 0.4

1 - p = 0.95
1 - p = 0.85
1 - p = 0.98

Ingat pada gambar ini yang diambil dari materi Logistic Regression? Seluruh probabilitas
yang tercipta dari tiap titik input tersebut digambarkan dalam sebuah probabilitas, dimana tiap titik
memiliki probabilitasnya masing - masing. Untuk itu, apabila kita memiliki klasifikasi yang lebih dari
dua kategori, akan sulit untuk menentukan berapa besar kemungkinan neuron untuk memilih output
tersebut. Untuk itu, kita bisa menggunakan salah satu fungsi lainnya, yaitu Softmax Function.
Softmax Function ini menghitung distribusi probabilitas terhadap tiap event yang akan
terjadi. Karena itu, seluruh kategori (event) akan dihitung seluruhnya dan berdasarkan distribusinya,
masing - masing probabilitasnya akan dihitung. Persamaan matematika yang digunakan adalah
sebagai berikut.

Untuk i = 1, 2, …, K
Untuk j = 1, 2, …, K

11
 Untuk tiap K event yang dapat terjadi, Softmax Function akan menghitung seluruh
penyebaran probabilitasnya. Karena itu, seluruh kategori dan klasifikasi akan memiliki nilai
probabilitas yang apabila seluruhnya dijumlahkan, akan bernilai 1. Kategori dengan probabilitas
tertinggi yang akan dipilih menjadi output bagi neuron tersebut. Apabila kita memiliki tiga klasifikasi
seperti warna merah (0,1), biru (0,6), dan hijau (0,3), maka neuron akan mengembalikan biru.

3. Cost Function dan Gradient Descent

Setelah kita banyak membahas mengenai input dan neural network, kita akan mencoba untuk
membahas output seperti apa yang dihasilkan dari Deep Learning ini. Ketika neural network
mengeluarkan sebuah output, output yang dikeluarkan ini berupa prediksi (ŷ) dimana sama seperti
Supervised Learning, kita perlu menguji apakah output yang dihasilkan ini akurat, dan sesuai dengan
nilai sebenarnya. Pertanyaan berikutnya yang muncul adalah, model Deep Learning ini kita buat
berdasarkan input yang kita berikan pembobotan (weight) dan nilai error (biases). Bagaimana cara
kita memperbarui weight dan biases ini?
Untuk membandingkan output dari neural network dan nilai sebenarnya, kita bisa
menggunakan yang dinamakan cost function / loss function. Fungsi ini menghasilkan sebuah nilai
yang digunakan untuk melihat seberapa besar perbedaan yang dihasilkan dari output neural network
dan nilai ini. Kita menamakan fungsi ini sebagai Loss Function, dengan harapan bahwa untuk tiap
pelatihan yang dilakukan nilai selisih (loss) akan berkurang.
Salah satu cost function yang paling umum digunakan merupakan quadratic cost function,
yang memiliki rumus matematika seperti berikut ini :

Nama lain dari rumus di atas merupakan Root-Mean Squared Error, dimana kita sudah sering
mendengar error metrics berikut ini karena kita sering menggunakannya pada materi Supervised
Learning. Rumusnya dibuat sedemikian, karena rumus tersebut digunakan untuk data yang memiliki
dimensi lebih dari 1, sehingga notasi penulisan rumus dibuat demikian.

12
 Namun, inti dari cost function tersebut adalah kita melihat perbedaan antara nilai sebenarnya
dengan nilai hasil prediksi. Notasi a pangkat L merupakan activation function terakhir yang paling
dekat dengan output. Apabila kita ingin menghitung error metrics pada layer sebelum itu, maka kita
bisa mengubah L menjadi L-1. Ingat pada konsep RMSE, kita menggunakan RMSE untuk
menghilangkan nilai negatif dan juga untuk menurunkan nilai error yang sangat besar.

Ketika kita menggunakan Python untuk membuat pemrogramannya, kita akan menuliskan
fungsi cost function ini menjadi berikut ini :

Dimana :

W merupakan bobot dari neural network, B merupakan nilai bias dari neural network, S^r
merupakan input untuk pelatihan sebuah neuron, sedangkan
merupakan output dari hasil pelatihan tersebut. Apabila kita memiliki neural network yang sangat besar,
maka nilai C tersebut juga akan menjadi besar, karena salah satu komponen didalamnya yaitu
merupakan hasil activation function pada layer akhir, yang berarti a(x) merupakan kumpulan dari
neural network yang digambarkan oleh W dan B.
Dengan banyaknya neural network yang terbentuk dalam deep neural network, bagaimana cara
kita menentukan weights yang tepat untuk meminimalisir nilai C? Pada pembahasan mengenai kalkulus,
kita pernah belajar bahwa untuk menentukan nilai maksimum (nilai yang menentukan nilai weights
dimana hasil derivative adalah 0) adalah dengan cara mencari nilai weights dengan menurunkan fungsi
C(w) dan menyamakan nilainya dengan 0. Akan tetapi, dengan banyaknya jumlah dimensi, walaupun
kita mencari nilai derivative, akan sangat memakan waktu, dan juga karena kita bicara mengenai deep
neural network, sudah pasti jumlah dimensi akan sangat besar.

13
 Cara untuk kita menghitung bagaimana mencari nilai weights terkecil untuk meminimalisir
nilai C disebut dengan Gradient Descent. Konsep ini digunakan dengan cara kita mengiterasi nilai
weights, lalu mencari pada titik mana weights akan membuat nilai C tersebut menjadi minimum. Kita
akan mencoba untuk mengilustrasikan bagaimana cara kita menggunakan Gradient Descent untuk
mencari nilai weights yang minimum.

C(w)

wmin
w

Perhatikan contoh fungsi weights tersebut. Kita menganggap fungsi tersebut merupakan C(w)
yang paling sederhana. Kita mulai dengan memilih sebuah titik secara acak, lalu kita mencari nilai
kemiringannya (slope/gradient).
C(w)

wmin
w

C(w)

wmin
w

14
 C(w)

wmin
w

Kita terus melakukan iterasi dan membuat gradient, sampai akhirnya kita menemukan nilai
kemiringan sama dengan 0, yang dimana kita memiliki nilai weights yang paling minimum. Panjang
langkah tiap iterasi dapat berpengaruh.
C(w)

wmin
w

C(w)

wmin
w

Semakin kecil langkah yang kita gunakan, maka semakin tepat kita mencari nilai weights
minimum, namun butuh waktu yang lebih lama untuk dapat mencapai titik tersebut, sedangkan
apabila kita menggunakan langkah yang besar, kita memiliki kemungkinan untuk melewatkan nilai
tersebut. Panjang langkah ini pada pembelajaran Deep Learning, kita sebut juga sebagai learning
rate. Kita juga dapat mengakali nilai ini dengan kita memulainya dengan langkah yang besar terlebih
dahulu, lalu dengan nilai slope yang semakin kecil, kita bisa mengurangi panjang langkah iterasi. Hal
ini kita sebut juga sebagai adaptive gradient descent.

15
 Berdasarkan penelitian yang dilakukan, dari banyaknya metode penggunaan Gradient
Descent, kita mendapatkan informasi bahwa Adam Optimizer merupakan metode Stochastic
Gradient Descent yang memiliki performa terbaik. Nama Adam ini sendiri datang karena metode ini
menggunakan estimasi adaptive moment.

Adam Optimizer dibuat hanya dengan menggunakan momen pertama dan kedua pada
gradient untuk membuat nilai learning rate dapat beradaptasi sendiri dengan keseluruhan nilai
weights yang ada. Dengan hanya menggunakan dua momen saja, maka jumlah memori Python yang
digunakan oleh Adam Optimizer sangat sedikit. Sebelum munculnya Adam Optimizer, banyak
metode lain seperti RMSP dan AdaGrad yang dapat digunakan, namun optimizer ini sulit untuk
digunakan pada seluruh kasus, dan hanya memiliki performansi yang bagus pada beberapa kasus
tertentu. Adam Optimizer ini terbukti memiliki performa yang baik dan stabil untuk hampir seluruh
kasus yang terjadi. Selain itu juga, hyper parameter yang ada dalam Adam memiliki interpretasi yang
luas dan juga tidak terlalu dilakukan pengaturan ulang untuk tiap layer pada neural network.
Walaupun bukan yang terbaik, namun terbukti Adam Optimizer terkadang memiliki performa yang
optimal sebagai sebuah fungsi optimisasi.
Demikian pembahasan mengenai metode gradient descent. Dengan melakukan hal ini pada
ruang N-dimensi, kita mengubah konsep vektor (menentukan arah pada ruang 2 dimensi) menjadi
tensor (penentuan arah pada ruang n-dimensi), dan notasi pun berubah dari derivative menjadi
gradient. Dengan berubahnya notasi, kita mengubah notasi C kita menjadi seperti berikut ini.

Menjadi :

Untuk menghitung cost function pada kasus klasifikasi, kita dapat menggunakan cross entropy
loss function. Fungsi ini memprediksi probabilitas untuk tiap kelas i = 1, 2, …. , C.

16
 Secara matematis, untuk menghitung nilai error, kita menggunakan fungsi logaritmik, yang
kita sebut juga sebagai log loss. Namun kita juga dapat menyebutnya sebagai cross-entropy apabila
kita gunakan rumus tersebut untuk menghitung selisih error. Untuk menghitung error pada M
(jumlah kelas) adalah 2, rumus matematika yang digunakan adalah sebagai berikut :

dengan :
p = nilai probabilitas yang diprediksi
y = indikator biner (0 atau 1)

Sedangkan untuk menghitung loss function untuk nilai M lebih dari 2 (M > 2), kita
menggunakan rumus umumnya yaitu sebagai berikut :

4. Backpropagation
Bagian ini merupakan bagian terakhir yang perlu kita pikirkan dalam membangun sebuah
model neural network. Pada bagian sebelumnya kita telah membahas bagaimana sebuah cost function
dan metode gradient descent dapat dilakukan, dan digunakan untuk mengubah nilai weights pada
network, supaya kita bisa memperbarui nilai weights yang digunakan untuk dapat mengurangi nilai
cost function selanjutnya. Kita akan membahas bagaimana caranya hasil weights yang baru dapat
dikembalikan pada input agar kita mendapat weights yang memperkecil nilai cost function.
Bagian ini disebut dengan backpropagation, karena kita akan melihat mundur untuk
memperbarui nilai weights yang digunakan sebagai input. Untuk mempermudah pemahaman, mari
kita lihat ilustrasi berikut ini.

w1 + b1 w2 + b2 w3 + b3

17
 Kita sudah memahami bahwa tiap input akan menerima sebuah weights dan biases nya masing
- masing. Dari cost function, kita juga mengetahui bahwa untuk penotasian layer, kita menggunakan
notasi berikut.

L-3 L-2 L-1 L

Ingat bahwa z = wx + b. Nilai x ini merupakan nilai input dari data pada layer pertama, karena
ini merupakan data asli. Ketika kita menuju ke layer kedua, x ini bisa kita anggap sebagai output dari
layer pertama, dan hasil output ini merupakan fungsi z yang dimana fungsi tersebut menjadi : a =
𝛔(z). Oleh karena itu, mari kita berfokus kepada dua layer terakhir, karena cost function dan gradient
descent, terutama apabila kita menggunakan Adam Optimizer, hanya menggunakan dua layer
terakhir.

L-1 L

Dengan nilai a merupakan output dari layer sebelumnya, dengan rumus yang sama, kita bisa
menuliskan fungsi z untuk layer terakhir seperti persamaan di atas. Nilai z pangkat L merupakan
notasi untuk z pada layer L, dan L bukanlah sebuah nilai angka. Kita juga memiliki persamaan lain
yang menyatakan bahwa nilai a pada layer L merupakan sebuah fungsi z pada layer L, dengan notasi
berikut:

Berdasarkan definisi dari cost function itu sendiri, kita mengetahui bahwa nilai cost function
merupakan persamaan berikut :

Tujuan kita adalah kita ingin mengetahui seberapa sensitif nilai cost function berubah dengan
perubahan weights. Oleh karena itu, kita dapat menuliskan derivative dari definisi tersebut.

18
 Dalam matematika, kita mengenal yang disebut sebagai chain rule, yaitu metode perkalian
dimana kita bisa memecah perkalian tersebut menjadi beberapa perkalian yang lebih kecil. Oleh
karena itu, notasi derivative tersebut dapat kita ubah menjadi seperti ini :

Dengan adanya chain rule, kita dapat memecah sebuah notasi derivative yang mungkin rumit
untuk dicari, menjadi beberapa fungsi kecil yang dapat kita kalikan. Secara umum, persamaan
tersebut dapat kita tuliskan menjadi berikut :

Ingat bahwa nilai cost function merupakan nilai selisih antara output prediksi dengan nilai
sebenarnya, kita bisa mengubah notasi tersebut menjadi berikut :

Oleh karena itu, kita dapat mengubah nilai cost function tersebut sehingga notasi persamaan
umum derivative tersebut menjadi seperti ini :

Persamaan di atas dapat disebut juga sebagai error vector. Dengan persamaan tersebut, kita
dapat mengubah notasi L yang tadinya kita menghitung mundur dari layer terakhir, menjadi
menghitung maju dari layer pertama dengan menuliskan notasinya menjadi seperti berikut :

Dimana nilai w^(L+1)T merupakan hasil transpose dari matriks weight dari layer L+1.
Persamaan tersebut juga menjadi persamaan matematika umum untuk mengetahui error dari masing -
masing layer L. Nilai 𑇐 𝛔’(z’) merupakan Hadamard Product, digunakan untuk memindahkan
errornya secara mundur menggunakan activation function pada layer L, sehingga memberikan kita
nilai ∂’ yang berupa input dengan weights pada layer L.

19
 Kita baru menyelesaikan persamaan yang digunakan untuk menghitung weights. Untuk
menghitung biases, kita menggunakan persamaan berikut :

Sebagai kesimpulan, kita akan menuliskan kembali persamaan derivative cost function dan
weights kita.

Dengan j dan k merupakan penanda jumlah layer. Kita tidak perlu khawatir untuk memahami
persamaan matematika, namun kita telah mengetahui konsep dari backpropagation. Untuk itu,
disertakan juga referensi mengenai bagaimana kita bisa memahami konsep matematika dari
backpropagation ini. Pada bagian pemrograman nantinya, kita sudah memiliki fungsi yang dapat
digunakan untuk langsung menghitung backpropagation ini tanpa harus memikirkan konsep
matematikanya.
Untuk memahami lebih lanjut mengenai proses penulisan sintaks pada Deep Learning, kita
akan menyertakan juga file Google Colab yang digunakan untuk mempelajari Deep Learning ini.
Sebelum kita masuk ke bagian pemrograman, ada baiknya kita memahami terlebih dahulu
penggunaan library Python Tensorflow dan Keras yang akan digunakan pada materi ini.

20
Apa itu PyTorch?
PyTorch merupakan sebuah library machine learning yang bersifat open-source yang
digunakan untuk mengembangkan dan melatih sebuah model neural network yang ada pada Deep
Learning. Library ini dikembangkan oleh tim dari Facebook AI Research (FAIR) pada tahun 2017,
dan masih populer digunakan untuk melatih sebuah model Deep Learning. PyTorch banyak
digunakan untuk melakukan optimisasi terhadap model Deep Learning berbasis tensor, dan banyak
digunakan untuk aplikasi yang menggunakan GPU dan CPU untuk bekerja. Selain library ini, library
lain yang cukup umum digunakan dalam pembuatan model Deep Learning lainnya adalah library
Tensorflow dan Keras (yang akan dibahas juga pada Bab ini nantinya).

Pengantar Tensor
Ketika kita menggunakan PyTorch, kita akan mengenal istilah mengenai tensor yang akan
sering disebutkan. Tensor merupakan sebuah matriks yang digeneralisasikan bentuknya. Umumnya,
untuk tensor dengan nilai rank yang rendah kita akan memiliki nama seperti skalar, vektor, matriks,
dan tensor, namun untuk dimensi yang lebih tinggi kita biasanya menyebutnya dengan sebutan tensor.
Kita cukup mengenal tensor dengan nol dimensi yaitu nilai skalar. Kita juga mengenal tensor dengan
satu dimensi dimana kita memiliki arah pada nilai tersebut yang disebut juga dengan vektor. Kita juga
mengenal istilah matriks dimana merupakan tensor dengan dua dimensi dimana memiliki besaran dan
arah. Sebuah tensor dapat memiliki lebih dari tiga dimensi, dan hal ini akan umum kita temukan
apabila nantinya kita menggunakan Deep Learning untuk melakukan pemrosesan menggunakan data
gambar. Untuk melihat ilustrasi lebih jelas mengenai tensor, kita dapat memahami gambar berikut ini.

21
 Apabila kita merepresentasikan angka pada ilustrasi di atas dalam bentuk dimensi, kita dapat
membayangkan sebuah tensor akan berbentuk seperti berikut ini.

Sebelumnya, kita mungkin mengenal library NumPy yang sebelumnya sering kita gunakan
pada beberapa contoh dalam Bab 4D - Reinforcement Learning. NumPy ini biasanya dapat
membuat array yang sifatnya 2 dimensi. Karena memiliki fungsi yang mirip, PyTorch dan NumPy
kadang kita gunakan bersamaan untuk melakukan konversi antar dimensi pada tensor, baik digunakan
dalam pemrosesan data maupun dalam pemantauan data itu sendiri ketika kita akan mengecek
validitasnya.

22
Apa itu Tensorflow?
Tensorflow merupakan salah satu library Python yang sifatnya terbuka untuk umum yang
dibuat oleh Google. Tensorflow memiliki versi yang terbaru yaitu Tensorflow 2.0 yang secara umum
dirilis pada tahun 2019 akhir. Tensorflow memiliki berbagai macam tools, fungsi, dan sumber daya
yang cukup untuk digunakan untuk membuat model Machine Learning, maupun Deep Learning.
Selain itu, Tensorflow juga biasanya sering digunakan bersamaan dengan library Keras, sehingga
pada Tensorflow versi 2.0, library Keras diadopsi oleh Tensorflow, sehingga membuat Keras secara
resmi merupakan API yang digunakan untuk berkolaborasi dengan Tensorflow.

Apa itu Keras?

Keras merupakan sebuah API tingkat tinggi yang dapat digunakan bersamaan dengan
Tensorflow, dan juga beberapa aplikasi backend lainnya seperti Theano. Keras memberikan
interaksi antarmuka yang baik kepada pengguna untuk membuat sebuah neural networks ataupun
Deep Learning model lainnya. Dengan menggunakan Keras, kita bisa menyatakan neural networks
dalam sebuah layer, dan kita bias membuat layer ini satu per satu dalam model Deep Learning
tersebut, sehingga memudahkan kita untuk membuat Deep Neural Network dan dengan mudah
bereksperimen dengan beberapa arsitektur lainnya.
Pada tahun 2019, Tensorflow merilis versi 2, dan karena Keras ini merupakan library yang
umum digunakan dalam Deep Learning, maka Tensorflow mengadopsi Keras ini didalamnya,
sehingga kita bisa memanggil Keras hanya dengan menginstal library Tensorflow. Namun, kita
dapat menggunakan library Keras ini tersebut, karena kita juga mempunyai versi Keras yang
terpisah yang sama seperti yang ada pada Tensorflow.

23
Study Case : Prediksi Jumlah Kalori Dalam Fast Food (PyTorch)

Pada pembahasan Deep Learning dengan metode artificial neural network, kita akan
membahas mengenai regresi dan juga klasifikasi. Kita akan membuat dua versi dimana yang satu kita
akan mencoba untuk menggunakan PyTorch untuk membuat model ANN dan juga menggunakan
Tensorflow dan Keras. Pada bagian ini, kita akan membahas mengenai regresinya terlebih dahulu
dengan menggunakan PyTorch. Untuk itu, kita akan menggunakan dataset yang sama seperti yang
kita gunakan pada materi regresi pada Supervised Learning, yaitu dataset berisi jumlah kalori pada
makanan fast food.
Untuk dataset yang akan kita gunakan berada pada file ini. Karena data yang kita gunakan
sama seperti yang kita gunakan pada materi Supervised Learning, kita bisa mengambil sintaks
tersebut agar kita tidak perlu melakukan EDA lagi dan hanya berfokus pada pembuatan model ANN
saja.

Menyiapkan File

Membuat Model PyTorch

Kita sudah melakukan proses untuk memisahkan data fitur dan label. Kita sekarang akan
berfokus dahulu untuk melihat bagaimana cara membuat sebuah model ANN dengan menggunakan
PyTorch. Kita akan memanggil library torch yang akan digunakan untuk membuat model tersebut.

Library torch adalah library yang kita gunakan untuk membuat ANN, sedangkan torch.nn
digunakan untuk membuat neural network pada model. Library torch.nn.function yang nantinya
akan kita gunakan untuk memberikan sebuah activation function pada model. Kita akan lihat
bagaimana cara kita membuat modelnya berikut ini.

24
 Untuk membuat model ANN ini, kita akan menggunakan struktur class pada Python untuk
memudahkan penulisan sintaks. Kita akan membuat class bernama Model dengan menuliskan
nn.Module yang akan mendefinisikan bahwa class tersebut akan berisikan neural network. Pertama
kita akan membuat sebuah fungsi def __init__(self) yang merupakan sebuah inisialisasi untuk class
tersebut. Kita menggunakan super().__init__() untuk mengeksklusifkan fungsi sehingga hanya
khusus digunakan pada class ini saja. Kita akan membuat sebuah layer yang dinamakan fc1, fc2, dan
out (dipanggil sebagai self.fc1, self.fc2, dan self.out karena merupakan inisialisasi class) dengan
menggunakan nn.Linear yang merupakan model linear. Angka 12,8 pada self.fc1 menandakan
jumlah input dan output pada layer tersebut. Karena kita memiliki 12 kolom pada data yang kita
miliki, maka kita akan menuliskan 12 dan mengeluarkan 8 layer. Angka 12 ini perlu dituliskan karena
mengikuti jumlah kolom fitur yang digunakan, sedangkan angka 8 ini bisa kita ganti dan
eksperimenkan sendiri. Kita akan membuat sebuah layer lain self.fc2 yang merupakan lanjutan dari
self.fc1, dengan input yang diterima adalah 8 (karena lanjutan dari self.fc1) dan output 16 (angka ini
bisa diganti sendiri). Terakhir kita akan membuat layer untuk output dimana angka input adalah 16
mengikuti angka lanjutan dari self.fc2 sedangkan angka outputnya adalah 1, yang menandakan hanya
1 kolom yang akan kita butuhkan sebagai output. Terakhir kita akan menyusun layer ini dalam fungsi
def forward(self,x) dengan menggunakan activation function ReLU. Kita akan memasukkan class
ini dalam variabel bernama model.

25
 Kita akan mengambil hanya nilai dari X dan y tersebut yang akan digunakan untuk membuat
tensor nantinya sehingga kita menggunakan fungsi values. Lalu dari library scikit-learn, kita akan
memanggil fungsi train_test_split untuk memisahkan data tersebut menjadi train data dan test data.
Setelah itu, kita perlu mengubah train data dan test data tersebut masing - masing menjadi bentuk
tensor, karena ingat sebelumnya bahwa keseluruhan data tersebut sebelumnya berbentuk skalar karena
kita menggunakan fungsi values. Untuk y_train dan y_test, kita akan menggunakan reshape untuk
mengubah bentuknya menjadi bentuk yang bisa dibaca oleh tensor, yaitu (-1,1).

Kita akan membuat sebuah loss function yang dimasukkan pada variabel criterion. Karena
data yang kita miliki merupakan data regresi, maka kita bisa menggunakan mean squared error untuk
menghitung nilai loss yang dihasilkan. Kita memanggil fungsinya dengan menuliskan
nn.MSELoss(). Kita juga tidak lupa memberikan optimizer dengan menggunakan Adam Optimizer.
Pada fungsi ini, kita memasukkan model.parameters() dan juga learning rate yang dibutuhkan
Adam Optimizer sebesar 0,01 (nilai ini bisa diganti tergantung kebutuhan). Variabel
model.parameters() ini berisikan informasi layer yang digunakan pada model yang kita miliki.
Apabila kita coba menjalankan variabel ini, kita akan melihat susunan dari model yang kita buat
sebelumnya. Perhatikan gambar berikut ini.

26
Proses Pelatihan dan Validasi

Setelah kita membuat model dan juga menentukan loss function dan juga optimizer yang akan
digunakan, sekarang kita akan melakukan proses pelatihan model dan juga validasi model. Proses
pelatihan akan menggunakan train data dan kita akan mengecek performa yang dihasilkan, sedangkan
proses validasi akan menggunakan test data untuk melihat apakah model berhasil untuk membuat
sebuah prediksi. Kita akan melihat sintaks yang digunakan untuk proses pelatihan berikut ini.

Kita akan melatih model kita sebanyak 100 kali. Pada tiap episode, kita akan melakukan
prediksi dengan menggunakan model.forward() yang kita buat sebelumnya pada class Model. Kita
juga akan menghitung loss yang dihasilkan dengan menggunakan fungsi criterion yang kita buat
sebelumnya. Nilai loss ini akan kita tambahkan dalam list agar nantinya bisa kita cek. Setelah
melakukan proses prediksi, kita tidak lupa untuk melakukan backpropagation seperti pada bagian
teori. Fungsi optimizer.zero_grad() akan membuat gradien pada tiap tensor menjadi bernilai 0, lalu
loss.backward() akan menghitung selisih gradien tersebut. Fungsi optimizer.step() akan menggeser
parameter satu kali, untuk digunakan pada perhitungan gradien pada episode selanjutnya.

27
 Apabila kita perhatikan, nilai loss pada tiap episode cenderung menurun. Hal ini sangat bagus,
dimana hal ini menandakan bahwa tiap episode membuat model kita semakin memiliki performa
yang baik untuk melakukan prediksi pada hasil train data. Kita dapat melihat performanya dengan
menggambarkannya pada sebuah grafik.

Apabila kita lihat grafiknya, nilai loss cenderung menurun dan memiliki nilai loss yang cukup
kecil pada episode ke 100, sekitar 2500 (MSE). Untuk itu, kita bisa mencoba tahap berikutnya, yaitu
untuk melakukan validasi terhadap model. Pada tahap ini, kita akan memberikan test data pada model
untuk melihat apakah model bisa melakukan prediksi dengan baik atau tidak.

Fungsi torch.no_grad() akan menghilangkan perhitungan gradien yang digunakan pada

backpropagation. Hal ini kita perlukan karena untuk validasi, kita tidak perlu menggunakan optimizer
dan menghitung gradien. Kita dapat lihat bahwa dengan menggunakan test data, nilai loss yang
dihasilkan adalah 538,47 (MSE). Apabila kita menggunakan RMSE, maka hasilnya hanya sekitar
23,2.

Menyimpan Model

Untuk menyimpan model, kita bisa menggunakan fungsi torch.save dari PyTorch, lalu
menyimpannya dalam bentuk file .pt.
28
Memanggil Kembali Model

Untuk memanggil kembali model yang kita simpan sebelumnya, kita bisa menggunakan
fungsi torch.load(), diikuti dengan nama file .pt tersebut. Kita bisa mengecek jumlah layer yang ada
didalamnya dengan menggunakan fungsi eval().

Mengujikan kembali Model dengan data Acak

Untuk memastikan apakah model kita dapat bekerja dengan baik atau tidak, maka kita akan
mencoba untuk memberikan sebuah data acak yang belum pernah dilihat oleh model sebelumnya.
Untuk menghasilkan data ini, kita akan mengambil data secara acak dari dataframe data asli yang kita
acak, dengan menggunakan fungsi random dan iloc pada Python.

Data tersebut adalah data acak yang kita ambil dari data asli kita. Kita akan mencoba untuk
memasukkan data tersebut pada model kita, dan melihat hasil prediksi yang diberikan.

Kita dapat membandingkan nilai prediksi tersebut dengan nilai kalori pada data asli.

29
Study Case : Prediksi Jumlah Kalori Dalam Fast Food (Tensorflow dan Keras)

Pada bagian sebelumnya, kita telah mencoba membuat model ANN sederhana dengan
menggunakan library PyTorch. Seperti yang telah kita bahas pada pembahasan teori sebelumnya, kita
bisa membuat model Deep Learning juga dengan menggunakan gabungan dari library Tensorflow
dan Keras. Pada bagian ini, kita akan mencoba untuk membuat sebuah model dengan menggunakan
dataset yang sama seperti kita gunakan pada contoh PyTorch, namun dengan menggunakan library
Tensorflow dan Keras. Pada akhir dari eksperimen ini, kita dapat membandingkan metode mana
yang lebih efisien.
Untuk dataset yang akan kita gunakan berada pada file ini. Karena data yang kita gunakan
sama seperti yang kita gunakan pada materi Supervised Learning, kita bisa mengambil sintaks
tersebut agar kita tidak perlu melakukan EDA lagi dan hanya berfokus pada pembuatan model ANN
saja.

Menyiapkan File

Membuat Train Test Split

Setelah kita memanggil file tersebut dalam Python, kita menganggap tidak ada nilai Null pada
data tersebut karena kita mengambil sintaks tersebut dari materi Supervised Learning. Sama seperti
pada materi supervised learning, kita akan memanggil fungsi train_test_split dari library scikit-
learn untuk memisahkan data yang akan digunakan untuk training dan data yang digunakan untuk
testing. Perhatikan sintaksnya berikut ini.

Kita juga akan menggunakan MinMaxScaler pada data tersebut agar seluruh data dapat
berkontribusi secara merata pada keseluruhan dataset. Perhatikan sintaksnya berikut ini.

30
 Kita menggunakan MinMaxScaler pada X_train dan X_test. Pada X_train, kita memasukan
data pada scaler, lalu melakukan transformasi untuk mengubah nilai tersebut menjadi antara 0 dan 1.
Pada X_test, kita hanya menggunakan transform dan tidak memanggil fungsi fit, untuk mencegah
adanya data test masuk kedalam data train.

Membuat Model Neural Network dan Melatihnya

Setelah ini, kita akan memanggil fungsi yang akan kita gunakan untuk membangun neural
network. Sebelumnya, pada materi supervised learning, kita memanggil fungsi tersebut dari library
scikit-learn. Untuk memanggil fungsi neural network, kita akan memanggilnya menggunakan
tensorflow.keras. Untuk menggunakan tensorflow ini, kita tidak perlu melakukan instalasi
menggunakan pip karena secara otomatis Google Colab telah memiliki library ini secara default.
Perhatikan cara penulisan sintaks untuk memanggil library tersebut.

Sequential merupakan model neural network yang akan kita buat, disebut Sequential karena
kita akan menyusun layer secara berurutan dari awal hingga pada akhirnya. Dense merupakan model
neural network yang terhubung satu sama lain, karena itu kita selalu memanggil Dense ini apabila
kita ingin membuat neural network yang terhubung satu sama lain.

Kita dapat membuat layer sejumlah dengan total fitur kita. Perhatikan bahwa pada X_train,
kita memiliki 360 data dengan 12 fitur. Karena itu, kita akan mencoba untuk membuat sebuah model
neural network dengan total 12 neuron yang terhubung.

31
 Kita akan memanggil fungsi Sequential() untuk membuat model berurutan. Perhatikan bahwa
kita akan menambahkan layer berisikan 19 neuron sebanyak 3 kali. Apakah jumlah 3 kali ini
merupakan jumlah yang tepat, kita tidak tahu sampai kita melakukan validasi nantinya. Ada
kemungkinan nilai ini menyebabkan overfit (memiliki performa baik pada saat pelatihan, namun
performa buruk saat validasi). Kita akan menambahkan satu layer Dense lagi pada akhirnya, untuk
menyatakan bahwa pada layer akhir merupakan output, yang hanya terdiri dari satu buah neuron saja
(jumlah kalori). Terakhir, kita akan mencoba menyusun model kita dan menuliskan adam sebagai
optimizer yang digunakan. Lalu karena kita menggunakan data regresi, maka loss yang akan kita
tuliskan sama seperti error metrics yang kita gunakan pada permasalahan regresi, yaitu salah satunya
adalah Mean Squared Error atau MSE. Kita menuliskan ‘mse’ untuk menyatakan kita
menggunakan MSE sebagai loss function kita.

Kita menggunakan fungsi fit() untuk memasukkan data pada model kita. Disini kita
memasukkan X_train dan y_train untuk sebagai train data, lalu sebagai validasinya, kita akan
memasukkan nilai X_test dan y_test. Kita menggunakan batch size bernilai 16, agar kita tidak
langsung memasukkan seluruh data sekaligus, melainkan kita memasukkan data sedikit demi sedikit,
agar model dapat bekerja lebih baik. Epochs merupakan jumlah episode yang memiliki arti bahwa
model tersebut akan bekerja untuk melakukan validasi sebanyak 100 kali. Kita akan mencoba untuk
menjalankan sintaks tersebut, dan melihat hasil output yang dikeluarkannya.

32
 Dengan adanya 100 Epochs, maka model akan dijalankan sebanyak 100 kali, dan kita akan
melihat 100 hasil output dari model tersebut. Angka 23 berarti jumlah data yang diproses, karena kita
menuliskan batch size sebesar 16, artinya untuk 360 data training yang kita miliki, maka tiap batch
akan berisi 23 data. Perhatikan bahwa nilai loss secara perlahan berkurang terus dengan bertambahnya
jumlah epoch.

Kita lihat bahwa pada jumlah Epoch mendekati nilai 100, kita mendapati loss kita semakin
mengecil dan hanya berkisar di 3200an.
Melakukan Validasi

Untuk melihat nilai loss dan juga val_loss yang dihasilkan, kita bisa menggunakan sintaks
berikut ini :

33
 Ketika kita menjalankan sintaks tersebut, kita mendapatkan data loss secara historikal dimulai
pada episode pertama sampai episode ke 100.

Kita juga dapat mengubah bentuknya menjadi sebuah dataframe agar lebih mudah untuk
dilihat.

34
 Kita akan mencoba untuk menggambarkan nilai loss tersebut.

Perhatikan bahwa nilai loss stabil pada sekitar episode ke 15. Kita tidak perlu melakukan
pelatihan sampai 100 episode apabila kita sudah mengetahui bahwa nilai loss tidak akan berkurang
lebih banyak lagi. Perhatikan juga apabila val_loss (validation loss) kita memiliki nilai yang tiba -
tiba tinggi pada suatu titik, maka ada indikasi bahwa data tersebut mengalami overfit. Pada gambar di
atas, kita tidak memiliki data overfit karena tidak ada kenaikan pada val_loss.
Dengan nilai loss yang cukup baik, kita akan mencoba untuk membuat prediksi dan juga
menguji seberapa besar error yang dihasilkan. Perhatikan cara penulisan sintaksnya berikut ini.

35
 Perhatikan bahwa nilai RMSE dan MAE yang dihasilkan secara berurutan adalah 60,96 dan
32,62. Apakah nilai ini merupakan nilai yang baik? Mari kita bandingkan dengan nilai sebenarnya.

Kita melihat bahwa nilai rata - rata kalori yang ada pada dataset aslinya adalah 530,91. Secara
median, kita juga melihat bahwa data tersebut berkisar pada nilai 490. Dengan hasil error MAE yang
kita miliki adalah 32,62 dan RMSE bernilai 60,96, kita dapat mengatakan bahwa nilai error yang
dihasilkan cukup kecil dan nilai MAE masih berada dibawah 10% dari rata - rata. Kita juga dapat
melihat nilai penyebarannya dengan menggunakan fungsi explained_variance_score yang kita
import sebelumnya.

Kita lihat bahwa nilai varians nya tinggi yaitu 0,95. Berarti data kita memiliki tingkat
keberagaman yang sangat tinggi. Kita juga bisa melihat nilai perbandingan antara y_test dan
prediction dengan menggambar data tersebut dalam sebuah scatterplot.

36
 Dari gambar yang dihasilkan, kita lihat bahwa hampir seluruh data berada pas pada garis, dan
memiliki nilai error yang sangat kecil dibandingkan dengan garis merah yang merupakan garis linear.
Hanya sedikit data yang jauh dari garis tersebut. Dengan demikian kita dapat menyimpulkan bahwa
model neural network yang kita buat untuk menyelesaikan permasalah perhitungan kalori ini dapat
berfungsi dengan baik.

Study Case : Prediksi Kemungkinan Membeli Seseorang Berdasarkan Gender, Umur, dan
Tingkat Penghasilan (PyTorch)

Setelah kita memahami bagaimana cara kerja Deep Learning dalam menyelesaikan
permasalahan yang terkait dengan regresi, kita akan mencoba untuk menyelesaikan permasalahan
yang terkait dengan klasifikasi. Sama seperti pada contoh regresi, kita akan mencoba untuk membuat
model klasifikasi dengan menggunakan PyTorch dan juga Tensorflow dan Keras. Kita akan
mencoba untuk membuat modelnya dengan PyTorch terlebih dahulu. Data yang kita akan gunakan
untuk bagian ini sama seperti data yang kita gunakan pada permasalahan klasifikasi yang kita bahas
pada materi Supervised Learning, yaitu kita menggunakan data perilaku pembelian seseorang
berdasarkan jenis kelamin, umur, dan juga tingkat penghasilannya. Data tersebut dapat kita akses pada
link berikut ini.
Sama seperti pada sebelumnya, karena kita sudah pernah melakukan EDA dan mengecek data
berikut ini pada materi Supervised Learning, kita hanya akan langsung mengambil sintaks yang
pernah digunakan agar kita tidak perlu melakukan EDA ulang kepada data tersebut. Perhatikan
penulisan sintaks berikut ini untuk melakukan EDA pada data berikut.

37
Menyiapkan File

Ingat bahwa pada data klasifikasi, apabila kita menemukan data yang bersifat kategorikal, kita
bisa mengubah dahulu data tersebut dengan menggunakan teknik one-hot encoding, sehingga data
tersebut berubah menjadi numerik dan dapat dianalisa dengan model kita.

Membuat Model PyTorch

Pada bagian ini, kita akan membuat model PyTorch. Kita akan menggunakan struktur class
untuk membuat model tersebut nantinya. Sebelum kita mulai membuat modelnya, kita akan
memanggil dulu library yang akan digunakan untuk pembuatan model PyTorch ini.

Struktur class yang kita gunakan untuk pembuatan model klasifikasi ini mirip dengan yang
kita buat sebelumnya pada model regresi. Kita akan menggunakan jumlah hidden layer yang sama,
dengan jumlah fitur input dan outputnya akan kita sesuaikan dengan data. Kita memiliki 3 fitur input
(Gender Male, Age, dan Estimated Salary), sedangkan kita memiliki 2 fitur output (0 dan 1) untuk
Purchased.

38
 Kita akan membuat class bernama Model. Pada bagian inisialisasi, kita akan membuat 3
layer, dimana pada layer pertama akan menerima input data dengan jumlah fitur adalah 3 dan
keluaran dari layer ini adalah 8. Kita akan membuat sebuah hidden layer (self.fc2) yang memiliki
input 8 layer dan keluaran 16 layer. Setelah itu kita akan membuat sebuah layer yang akan
mengeluarkan output dengan jumlah input 16 layer dan output 2 layer. Class yang dibentuk ini akan
kita masukkan dalam variabel model. Bentuk dari struktur ANN yang kita buat ini menyerupai
dengan yang kita buat pada model regresi. Jumlah hidden layer dapat disesuaikan dengan kebutuhan.
Setelah membuat model tersebut, kita akan melakukan pre-processing awal terhadap data yang
kita miliki. Karena kita melakukan prediksi mirip dengan yang kita lakukan pada Supervised
Learning, kita akan membagi data kita menjadi train data dan test data. Kita akan menggunakan
library dari scikit-learn yaitu train_test_split untuk membantu kita memecah data tersebut.

39
 Data yang kita miliki masih berbentuk data NumPy. Agar data tersebut dapat diolah dengan
menggunakan PyTorch, kita perlu mengubah data tersebut menjadi sebuah tensor. Data pada fitur
input akan kita ubah sebagai tipe data float sesuai dengan format data yang dapat diterima oleh
PyTorch, sedangkan data pada label output akan kita ubah sebagai tipe data long sesuai dengan
format data yang dikeluarkan oleh PyTorch. Perhatikan gambar berikut untuk merubah tipe data dari
data yang kita miliki.

Kita juga akan membuat sebuah loss function yang digunakan untuk menghitung loss dari
proses pelatihan pada model ANN kita. Karena model yang kita buat merupakan model klasifikasi,
kita akan menggunakan Cross Entropy sebagai loss function. Kita juga membuat sebuah optimizer
dengan menggunakan Adam Optimizer yang digunakan untuk gradient descent dan membuat model
kita dapat belajar lebih baik.

Kita menggunakan learning rate sebanyak 0,01, untuk menghindari perpindahan gradien yang
terlalu besar. Optimizer tersebut digunakan pada model.parameters(). Untuk mengecek
model.parameter(), kita bisa lihat apa isi dari parameter tersebut.

Setelah kita membuat optimizer, loss function, dan model yang akan digunakan, sekarang kita
akan memulai untuk melatih model kita. Kita menggunakan 100 episode pelatihan untuk melatih
model kita.
40
 Kita akan melatih model ANN tersebut dalam 100 kali episode pelatihan. Untuk tiap episode
kelipatan 10, kita akan mencatat nilai loss yang dihasilkan. Perhatikan bahwa pada awal - awal
pelatihan, kita memiliki nilai loss yang besar, sampai pada episode ke 40 tetap mengecil. Namun kita
dapat perhatikan bahwa pada episode ke 50, nilai loss meningkat kembali, lalu kembali turun pada
episode ke 70. Namun setelah itu nilai loss kembali meningkat sampai pada episode ke 90, kita
memiliki nilai loss sebesar 22,04. Apabila kita gambarkan nilai loss tersebut dalam sebuah grafik
garis, kita akan mendapat gambar seperti berikut ini.

41
 Kita dapat lihat bahwa nilai loss tidaklah stabil untuk model di atas. Kita bisa menyesuaikan
beberapa parameter untuk dapat diubah agar kita memiliki nilai loss yang lebih kecil dan lebih stabil.
Setelah proses pelatihan model selesai, kita akan mencoba untuk melakukan validasi terhadap
model kita dengan menggunakan test data. Perhatikan gambar berikut ini.

Kita kita mencoba untuk menghitung nilai loss yang dihasilkan dari menggunakan test data,
kita mendapatkan nilai loss adalah 68,16. Nilai ini cukup rendah, namun kita masih memiliki nilai
loss yang lebih rendah ketika kita melakukan pelatihan dengan menggunakan train data. Kita akan
mencoba untuk menghitung, dengan nilai loss sebesar 68,16, ada berapa banyak data benar yang
diprediksi oleh model. Perhatikan gambar berikut ini.

42
 Kita mendapatkan bahwa model kita berhasil melakukan prediksi dengan tepat sebanyak 52
nilai benar. Hasil tersebut bukanlah merupakan hasil yang baik. Untuk dapat memperbaiki
performanya, kita bisa memperpanjang jumlah episode pelatihan, maupun mengubah beberapa
parameter yang kita gunakan pada model, seperti jumlah hidden layer yang digunakan, atau
meningkatkan nilai learning rate, agar mendapat nilai loss dan akurasi yang lebih baik lagi.

Study Case : Prediksi Kemungkinan Membeli Seseorang Berdasarkan Gender, Umur, dan
Tingkat Penghasilan (Tensorflow dan Keras)

Sebelumnya kita telah memahami bagaimana cara kerja Deep Learning dalam menyelesaikan
permasalahan regresi, dan juga kita telah membahas bagaimana penggunaan library PyTorch untuk
membuat model ANN yang dapat menyelesaikan permasalahan klasifikasi. Pada bagian kali ini,
dengan menggunakan data klasifikasi yang sama, kita akan mencoba membuat kembali model dengan
menggunakan library Tensorflow dan Keras. Kita akan mencoba melihat performa dari penggunaan
library Tensorflow dan Keras ini, dan kita dapat membandingkan performa model yang akan kita
buat ini dengan model yang sebelumnya kita buat dengan menggunakan PyTorch. Data tersebut dapat
kita akses pada link berikut ini.
Sama seperti pada sebelumnya, karena kita sudah pernah melakukan EDA dan mengecek data
berikut ini pada materi Supervised Learning, kita hanya akan langsung mengambil sintaks yang
pernah digunakan agar kita tidak perlu melakukan EDA ulang kepada data tersebut. Perhatikan
penulisan sintaks berikut ini untuk melakukan EDA pada data berikut.

43
Menyiapkan File

Ingat bahwa pada data klasifikasi, apabila kita menemukan data yang bersifat kategorikal, kita
bisa mengubah dahulu data tersebut dengan menggunakan teknik one-hot encoding, sehingga data
tersebut berubah menjadi numerik dan dapat dianalisa dengan model kita.

Membuat Train Test Split

Sama seperti pada pembahasan kita mengenai data regresi, kita juga akan melakukan
preprocessing terlebih dahulu terhadap data kita. Kita akan memisahkan data kita menjadi fitur dan
juga label, dan juga kita akan memanggil fungsi train_test_split untuk membagi data kita menjadi
train data dan test data.

44
 Setelah kita memisahkan train data dan test data, kita akan melakukan preprocessing dulu
terhadap data kita. Kita akan menggunakan MinMaxScaler untuk mengubah rentang data yang kita
miliki.

Membuat Model Neural Network

Kita akan membuat model neural network pada bagian ini. Kita akan menggunakan model
Sequential dan juga Dense dari library Keras. Perhatikan penulisannya berikut ini.

Kita akan mengecek jumlah fitur pada X_train. Dapat kita lihat bahwa kita hanya memiliki 3
fitur, yang menunjukkan masing - masing adalah jenis kelamin, umur, dan juga tingkat penghasilan.
Kita akan membuat sebuah layer yang berisikan 3 input pada fitur, lalu membuat 15 layer.

45
 Karena kita hanya memiliki 2 kelas output, yaitu antara 0 atau 1 dimana 0 menunjukkan
bahwa customer tersebut tidak akan melakukan pembelian dan 1 menunjukkan bahwa customer
tersebut memiliki peluang untuk melakukan pembelian, maka kita hanya akan menuliskan Dense
sama dengan 1 pada bagian akhir (hanya 1 layer). Perhatikan bahwa pada output, kita menggunakan
activation function sigmoid. Ingat pada penjelasan pada bagian teori, bahwa kita dapat menggunakan
sigmoid function untuk menyelesaikan permasalahan klasifikasi dengan jumlah output biner.

Validasi Model

Setelah kita membuat layer neural network kita, kita akan mengkompilasi model tersebut
dengan menuliskan optimizer yang akan kita gunakan dan jenis perhitungan loss yang digunakan.
Ingat pada bagian teori, bahwa apabila kita melakukan klasifikasi, kita menggunakan cross entropy
sebagai loss functionnya, dengan kita menuliskannya sebagai binary_crossentropy. Kita tetap akan
menggunakan adam optimizer. Lalu kita akan memasukkan train data kedalam model, lalu
menuliskan berapa banyak jumlah episode yang akan dijalankan oleh model, lalu kita tidak lupa juga
menuliskan data yang digunakan untuk validasi untuk melatih model tersebut. Kita akan mencoba
menjalankan sintaks tersebut untuk mendapatkan hasil pelatihan per episodenya.

46
 Semakin banyak jumlah episode yang dimainkan, kita dapat melihat bahwa jumlah loss
semakin berkurang. Kita juga dapat lihat ketika kita sampai pada episode 590an, nilai loss cukup
stabil di sekitar angka 0,348. Kita akan melihat bagaimana pola penurunan loss kita dengan
menggambarkan loss tersebut.

47
 Sama seperti pada contoh pada regresi, sepertinya jumlah episode yang dituliskan sangat
banyak, sehingga kita lihat setelah melewati beberapa episode tertentu, model tidak ada improvement
lagi, dan nilai loss tetap stabil. Untuk itu, kita akan melihat berapa jumlah episode yang optimal untuk
dituliskan. Kita bisa menggunakan fungsi dari Keras, yaitu EarlyStopping. Fungsi ini akan secara
otomatis memberhentikan proses pelatihan data, ketika kondisi metrics yang di monitor telah
terpenuhi. Berikut contoh penulisan sintaksnya.

Pada fungsi EarlyStopping, kita memiliki beberapa parameter yang dapat dituliskan.
Monitor merupakan metrics yang akan kita lihat performa nya. Disini yang kita akan hitung
merupakan variabel ‘val_loss’. Mode kita tuliskan ‘min’, ini menandakan kita akan memonitor
variabel ini sampai nilainya menjadi nilai minimumnya. Parameter Mode ini memiliki tiga jenis,
yaitu ‘auto’, ‘min’, dan ‘max’. Karena yang akan kita monitor merupakan metrics dari loss function,
kita tentu menginginkan nilai yang minimum, maka dari itu, kita menggunakan ‘min’. Kita
menuliskan verbose = 1 agar tidak terlalu banyak informasi yang ditampilkan pada proses pelatihan.
Parameter Patience digunakan untuk memantau kembali hasil, apabila kita sudah mencapai nilai loss
terendah kita, model akan kembali melihat untuk 25 episode kedepan, untuk berjaga - jaga apabila
model masih bisa menghasilkan nilai loss lebih rendah lagi atau tidak. Perhatikan hasilnya apabila
kita melakukan pelatihan ulang, dengan menuliskan fungsi EarlyStopping berikut ini.

48
 Perhatikan outputnya ketika kita menjalankan ulang model kita.

Perhatikan bahwa kita tetap menjalankan 600 episode yang kita tuliskan sebelumnya. Ini
berarti bahwa EarlyStopping tidak mendeteksi adanya peningkatan nilai loss dan nilai loss terus
berkurang selama 600 episode berjalan. Pada pelatihan kali ini, kita juga melihat bahwa performa
model semakin baik, kita bisa mendapatkan nilai loss terendah sebesar 0,2569 kali ini, sedangkan
pada sebelumnya, pada episode ke 600, kita mendapatkan nilai loss sebesar 0,348.
Walaupun kita tidak melihat performa dari fungsi EarlyStopping ini, namun kedepannya
fungsi ini dapat dipakai untuk pencegahan agar tidak terjadi overfit ketika kita melakukan pelatihan
terhadap model.

49
 Cara lain yang bisa kita gunakan untuk mencegah adanya overfit dan memiliki model dengan
performa yang lebih baik adalah dengan memberikan layer Dropout, dengan memanggil fungsi
Dropout. Cara kerja dari fungsi ini adalah kita akan mematikan sejumlah neuron dalam neural
network, sehingga nilai weights dan biases pada neuron ini tidak akan diperbarui, dan neuron tersebut
tidak akan digunakan. Hal ini dilakukan untuk mencegah adanya peningkatan nilai loss apabila pada
model awal kita, kita memiliki nilai loss yang tidak stabil dan juga peningkatan yang signifikan.
Untuk memanggil fungsi Dropout ini, kita memanggilnya dari tensorflow.keras.layers. Perhatikan
penulisan sintaksnya berikut ini.

Karena Dropout ini merupakan bagian dari library layer, maka kita menuliskan Dropout ini
diantara layer pada model kita.

Parameter angka pada Dropout menunjukkan persentase probabilitas dimana neuron pada
layer sebelumnya akan aktif. Ketika kita menuliskan 0,5 maka 50% dari neuron pada layer
sebelumnya akan diaktifkan, dan sisa 50% nya akan dimatikan ketika nilai loss sudah mencapai
sebuah nilai yang signifikan menurut model. Dengan ini, kita bisa mencegah adanya overfit terhadap
model kita. Ketika kita menjalankan sintaks di atas, kita akan mendapatkan hasil seperti berikut ini.

50
 Perhatikan bahwa kali ini, fungsi EarlyStopping kita bekerja, dan model berhenti melakukan
pelatihan pada episode ke 281. Menurut model, kita hanya membutuhkan 281 episode pelatihan untuk
mencegah terjadinya overfit. Namun kita lihat, bahwa pada episode ke 281 ini, kita memiliki nilai loss
sebesar 0,5377. Apakah nilai ini merupakan nilai yang baik? Mari kita lihat hasil dari lossnya dalam
bentuk gambar.

51
 Ketika kita memberikan sebuah layer Dropout, maka hasil loss nya akan memiliki banyak
noise, sehingga dapat kita lihat bahwa nilai nya tidak begitu stabil. Untuk itu, kita bisa
mempertimbangkan apakah kita perlu menambahkan sebuah layer Dropout atau tidak, ataupun
mempertimbangkan apakah persentase jumlah neuron yang aktif akan diubah atau tidak, untuk
mendapatkan nilai loss yang lebih baik dan mencegah terjadinya overfit terhadap data.
Dengan telah melihat beberapa variasi yang kita telah lakukan, kita melihat bahwa model
tanpa diberikan Dropout memiliki performa yang lebih baik. Kita akan membuat kembali model
tersebut, lalu mencoba untuk melakukan prediksi terhadap data kita.

52
Membuat kembali Model dengan Performa yang Lebih baik

Kita telah melihat bahwa tanpa menggunakan Dropout, kita memiliki performa yang lebih
baik. Kita akan membuat kembali model tersebut, dan melihat hasil pelatihannya. Kali ini, fungsi
EarlyStopping kita aktif dan tidak perlu menunggu sampai 600 episode.

Kita akan menggunakan predict untuk melihat hasil prediksi dari model yang telah kita buat
ini.

Perhatikan bahwa penulisan predict sedikit berbeda dan kita menggunakan argmax dari
numpy untuk melakukan prediksi, karena untuk menentukan prediksi kategorikal, kita tidak bisa
menggunakan predict secara langsung pada Keras. Karena itu, kita akan menggunakan argmax
untuk mengambil posisi indeks dari nilai maksimumnya.

53
 Kita akan mengecek tingkat akurasi yang dihasilkan dari model ini. Sama seperti supervised
learning, kita akan menggunakan classification report untuk melihat hasil dari permasalahan
klasifikasi. Berikut contoh penulisan sintaksnya.

Perhatikan bahwa walaupun nilai loss kita terbilang kecil, kita masih mendapatkan tingkat
akurasi yang kurang baik dalam melakukan prediksi terhadap data yang kita miliki.

Kita juga memiliki 47 nilai yang tidak sesuai dalam data prediksi kita. Sebagai kesimpulan,
agar kita memiliki tingkat akurasi yang lebih baik lagi, kita dapat mencoba untuk mengubah - ubah
parameter, seperti mengubah jumlah neuron, memberikan layer Dropout, lalu bisa juga memberikan
jumlah episode pelatihan yang lebih banyak lagi, dan lainnya untuk dapat meningkatkan performa
dari model yang kita buat.

54
Recurrent Neural Network
Kita telah mempelajari konsep dari Artificial Neural Network (ANN) sederhana pada bagian
sebelumnya, dimana kita bisa menggunakan Tensorflow dan Keras untuk membuat beberapa layers
yang berperan sebagai neural network, yang digunakan untuk bisa mengekstrak beberapa informasi
penting dari sebuah data input, sehingga menghasilkan nilai output yang bernilai lebih baik.
Pada ANN juga sebelumnya kita telah mempelajari bagaimana penggunaan dan teori dasar
mengenai Deep Learning, bagaimana cara kerja tiap langkah dan juga beberapa fungsi yang
digunakan untuk membangunnya, seperti activation function, loss function dan gradient descent. Pada
materi kali ini, kita akan membahas variasi lain dari ANN, yang disebut juga Recurrent Neural
Network (RNN).
Recurrent Neural Network (RNN) merupakan salah satu cabang dari Deep Learning, yang
biasa berfokus untuk menghadapi data yang bersifat berurutan antar datanya. Contoh data ini seperti
data yang melibatkan waktu, atau data yang berurutan seperti data teks yang digunakan untuk
Natural Language Processing (NLP). Karena urutan berperan penting dalam RNN, kita tidak bisa
begitu saja menggunakan train test split seperti yang kita lakukan pada ANN, karena ini akan
membuat data menjadi berantakan apabila kita mengacak urutan data tersebut dengan menggunakan
train test split.
Karena urutan berperan penting, kita bisa menggunakan RNN untuk dapat memprediksi hasil
pada urutan selanjutnya. Hal ini membuat RNN cocok digunakan untuk melakukan prediksi beberapa
urutan atau waktu kedepannya, dimana hal ini biasa kita sebut juga sebagai ramalan (forecasting).
Sebelum kita memulai untuk membuat contoh programmingnya, kita akan membahas sedikit
mengenai teori dan cara kerja dari RNN ini sendiri.

Konsep
Sebelum lebih jauh membahas mengenai RNN, ada baiknya kita mengetahui dulu jenis - jenis
data seperti apa yang sifatnya berurutan. Data yang berurutan memiliki ketergantungan dari data yang
berada pada posisi sebelumnya.

55
 Beberapa contoh aplikasi dari data yang berurutan adalah : (1) Time-Series Data, atau data
yang bergantung pada waktu seperti data transaksi, (2) Data berisi kalimat, (3) Data Audio, (4) dan
data lainnya yang memiliki urutan atau mementingkan posisi indeks. Pada RNN ini, kita akan
berfokus apabila kita memiliki suatu urutan pada sebuah data, apakah RNN ini dapat melakukan
prediksi apabila kita melihat kemiripan terhadap data input tersebut. Perhatikan ilustrasi berikut :

1 2 3 4 5 3 4 5 6 7

Input Output (?)

Apabila kita meminta manusia untuk memprediksi nilai output tersebut, kita bisa dengan
mudah menyebutkan angka berikutnya adalah 3, 4, 5, 6, 7 karena kita melihat pola input berselisih 1
nilai terhadap angka sebelumnya. Namun hal ini akan berbeda ketika kita meminta komputer untuk
melakukan hal tersebut. Ketika kita memiliki jenis input berurutan seperti di atas, yaitu angka 1
sampai 5, kita perlu memastikan apakah model yang kita buat dapat memprediksi hasilnya untuk
mengeluarkan output seperti angka 3 sampai 7 atau tidak.
Agar komputer dapat melakukan hal ini, komputer perlu belajar data historikal mengenai
berbagai macam jenis output. Karena itu, kita mendapatkan sebuah konsep bahwa dalam RNN, kita
akan mengembalikan output tersebut menjadi sebuah input untuk model. Hal ini mengakibatkan
munculnya sebuah konsep yang disebut sebagai feedback. Perhatikan ilustrasi berikut ini.

Time
Output Output Output Output
t-1 t t+1

Input Input Input Input

t-1 t t+1
56
 Pada ilustrasi sebelumnya, kita menggambarkan bahwa RNN akan mengembalikan nilai
output menjadi input untuk proses selanjutnya. Ingat bahwa pada ANN, kita memberikan berbagai
macam jenis input untuk dilihat hasil outputnya, dan kita tidak melakukan feedback untuk
mengembalikan output tersebut menjadi input pada proses selanjutnya. Pada RNN, kita melihat
bahwa hasil output pada t -1 akan menjadi input bagi proses selanjutnya (t), dan akan terus berulang.
Hal ini memungkinkan model tersebut dapat belajar dari data output historikal.
Fungsi input yang dihasilkan dari output pada proses sebelumnya disebut juga sebagai
memory cell, karena sel ini merupakan hasil output historikal. Dengan konsep tersebut, kita bisa
menyimpulkan bahwa dengan RNN, kita bisa menghasilkan banyak output dari banyak input (many-
to-many).

Akan tetapi, kita juga bisa mencari hanya satu output vector. Hubungan tersebut disebut
sebagai many-to-one.

Secara keseluruhan, banyak kombinasi antara input dan output yang bisa dihasilkan dari
bentuk RNN berikut ini. Berikut merupakan kombinasi yang bisa dihasilkan dari model RNN
tersebut.

57
 Dari konsep tersebut, beberapa aplikasi yang dapat terbentuk adalah kita bisa membuat sebuah
chatbot. Hal ini dapat diimplikasikan ketika kita memberikan 1 pertanyaan pada komputer, kita
berharap komputer tersebut dapat memberikan kita lebih dari satu jawaban atau satu cara (One-to-
Many). Contoh lain adalah ketika kita ingin membuat prediksi dari data demografi seseorang, apakah
seseorang tersebut akan melakukan transaksi kelima dengan mempertimbangkan empat transaksi
yang sebelumnya dilakukan (Many-to-One).
Sebagai kesimpulan, kita dapat menggunakan RNN ini untuk menyimpan data historikal yang
lebih lama, sehingga terkadang data historikal yang tersimpan ini diharapkan dapat disimpan dalam
jangka panjang (long-term).

Teori
Gradients, LSTM, dan GRU

Ketika kita membahas mengenai RNN, ada beberapa hal yang perlu kita perhatikan, seperti
Exploding Gradients dan Vanishing Gradients. Ingat bahwa kita memerlukan gradient untuk
mengatur ulang nilai weights dan biases kita. Semakin kompleks model dan data yang kita miliki, kita
akan memiliki neural network yang semakin banyak (Deep Neural Network). Semakin banyak layer
yang digunakan, kita akan memiliki fungsi derivative yang semakin banyak, sehingga ketika
melakukan backpropagation (kembali ke layer awal), biasanya gradient akan semakin kecil, sehingga
terkadang nilai weights tidak akan berubah banyak.
Bagaimana permasalahan ini berdampak pada RNN? Kita ingat bahwa output akan
dikembalikan menjadi input pada RNN. Ketika kita memiliki model yang terlalu kompleks (dalam),
gradients akan menjadi sangat kecil sehingga terkadang nilai weights tidak akan terlalu berubah
banyak, sedangkan kita membutuhkan nilai weights tersebut untuk menyesuaikan kembali input kita.

58
 Masalah lain yang sering muncul adalah, RNN cenderung melupakan input yang awal.
Perhatikan bahwa kita menggunakan output dari model yang dikomputasi pada waktu t-1, dan pola
tersebut akan berulang, sehingga menyebabkan RNN dapat “melupakan” input awal yang diberikan.
Semakin panjang dan lama waktu yang dibutuhkan untuk melatih model, hal ini cenderung dapat
terjadi. Kita membutuhkan memori yang dapat menampung nilai ini lebih lama agar model tidak
melupakan input tersebut, sehingga kita memiliki istilah Long Short-Term Memory (LSTM) yang
dibuat untuk menyelesaikan masalah ini. Perhatikan ilustrasi berikut ini.

Output t-1 Output t

Ht = tanh(W[Ht-1, Xt] + b)
(Ht-1) (Ht)

Input t
(Xt)

RNN akan memasukkan output pada waktu t-1 bersamaan dengan input Xt kedalam activation
function yang merupakan sebuah fungsi weights dan biases, disini kita anggap activation function
tersebut merupakan hyperbolic tangent. Kita sudah bahas sebelumnya bahwa kita membutuhkan
memori yang dapat menampung nilai lebih lama agar RNN tidak melupakan input nya, yaitu LSTM.
Pada LSTM, kita memiliki diagram seperti berikut.

Ht
New Long-
Long-Term Term Memory
Forget Output
Memory Gate Gate

New Short-
Short-Term Input Gate
Update
Gate Term Memory
Memory

Xt

59
 Dalam sebuah LSTM, sebenarnya ada 4 gate yang akan bekerja. Gate ini hanyalah sebuah
neural network yang masing - masing memiliki fungsi yang berbeda. Forget gate akan berperan untuk
“melupakan” informasi yang tidak kita butuhkan. Input gate akan berperan untuk menerima
informasi yang masuk pada LSTM. Output gate akan berperan untuk mengeluarkan informasi untuk
neuron selanjutnya. Update gate akan menentukan informasi apa yang akan diperbarui untuk neuron
selanjutnya. Keseluruhan bentuk gate ini merupakan representasi dari bentuk persamaan matematika.
Kita akan mengubah persamaan tersebut menjadi notasi matematika.

ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Ilustrasi di atas merupakan representasi matematika dari apa yang terjadi dalam sebuah
LSTM. Fungsi ft merupakan sebuah forget gate, yang berupa sigmoid function. Apabila nilainya
mendekati 0, maka LSTM akan melupakan hal tersebut, sedangkan apabila mendekati 1, LSTM
akan tetap mengingat nilai tersebut.
ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

60
 Fungsi it dan Ct merupakan informasi input yang diterima oleh LSTM, yaitu input gate.
Fungsi it menentukan input yang mana yang perlu kita perbarui dengan nilai weights yang baru.
Fungsi Ct akan membuat sebuah vektor yang merepresentasikan nilai input.
ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Fungsi Ct merupakan cell state, dimana fungsi ini membawa informasi penting dari sel untuk
ke layer berikutnya. Nilai ini didapatkan dengan menghitung nilai yang didapat dari forget gate dan
menjumlahkannya dengan nilai yang didapat dari input gate.
ht

+ Ct
Ct-1 x
tanh

X
ft X
It Ct

ht-1
σ σ tanh σ
ht

Xt

Terakhir, kita memiliki sebuah fungsi ht yang merupakan hidden state. Nilai ht dan Ct ini akan
diteruskan sebagai output ke layer LSTM berikutnya. Fungsi tersebut merupakan perkalian dari hasil
output neuron dengan nilai hyperbolic tangent dari update gate.
Ilustrasi di atas merupakan ilustrasi dasar dari sebuah LSTM yang sederhana. Banyak
ilmuwan yang mengembangkan model LSTM ini dan menambahkan atau memodifikasi jalur
didalam sel LSTM tersebut untuk performa yang lebih baik.

61
 Salah satu sel LSTM lain yang mulai populer di tahun 2014 adalah Gate Recurrent Unit
(GRU). Pada GRU, kita memiliki sel yang lebih sederhana dibandingkan dengan LSTM, yaitu tidak
adanya output gate.

RNN Batches
Setelah kita membahas konsep teori bagaimana RNN dapat bekerja dan juga bagaimana kita
menggunakan LSTM sebagai sel untuk memperbarui nilai weights dan juga mengatasi permasalahan
gradients, kita akan melihat, seperti apa bentuk data yang dapat diproses oleh RNN.
Ingat bahwa RNN akan mengolah data yang bersifat berurutan (sekuensial). Karena data ini
sifatnya berurutan, kita akan mengalami kesulitan apabila kita mengacak data tersebut
menggunakan metode train test split. Kita akan mengingat kembali apa yang kita lakukan pada materi
Reinforcement Learning ketika kita membuat sebuah pelatihan untuk agent. Kita ingat bahwa untuk
memecah data yang sifatnya sekuensial, kita bisa menggunakan batches. Bayangkan kita mempunyai
data seperti berikut.

0 1 2 3 4 5 6 7 8 9

Dengan data seperti di atas, kita bisa memecah data tersebut menjadi beberapa opsi batches,
seperti berikut ini :
0 1 2 3 4 5 6 7 8 9

3 4 5 6 7 8

0 1 2 3 4 5

62
 Untuk dapat menentukan bagaimana cara kita memecah data tersebut menjadi beberapa
batches, tidak ada teori ataupun cara yang tepat, kita memerlukan pengetahuan seperti domain
knowledge untuk dapat menentukan bagaimana cara yang tepat untuk memecah data tersebut
menjadi batches. Namun satu hal yang dapat kita lakukan, kita bisa menyisakan sebagian kecil data
untuk digunakan sebagai pembanding. Ketika kita mempunyai 10 data pada ilustrasi sebelumnya,
kita dapat menyisakan 1 data yang akan digunakan untuk memprediksi urutan data selanjutnya.
Perhatikan bahwa konsep ini berbeda dengan menggunakan train test split, karena kita akan
melakukan prediksi pada data yang bahkan kita tidak tahu data tersebut benar atau salah. Ini kita sebut
sebagai forecast.

Apabila kita memiliki data yang sifatnya seasonal atau berulang, misalkan kita memiliki tren
bahwa tiap 1 tahun kita memiliki dua kali kenaikan, maka kita bisa menggunakan data 1 tahun
terakhir untuk memprediksi atau melakukan forecast untuk data 1 tahun kedepan.
Untuk melakukan sebuah forecast, kita menggunakan RNN untuk dapat mengembalikan nilai
output tersebut menjadi sebuah input untuk forecast selanjutnya. Perhatikan ilustrasi berikut.

- [6, 7, 8, 9] → [10]
- [6, 7, 8, 9, 10] → [11.2]
- [6, 7, 8, 9, 10, 11.2] → [12.6]

Perhatikan setiap kali kita melakukan sebuah forecast, kita dapat lihat bahwa error yang
dihasilkan akan semakin besar. Hal ini disebabkan karena kita melakukan forecast terhadap data
forecast, sehingga kemungkinan error meningkat akan semakin besar.

63
Study Case : Prediksi Penjualan Liquor pada Iowa (PyTorch)

Pada pembahasan kali ini, kita akan mencoba untuk mengaplikasikan RNN pada sebuah data
yang cukup terkenal, yaitu data penjualan liquor dari negara Iowa. Data ini merupakan data yang
bersifat publik, dan dipublikasikan dengan tujuan untuk pembelajaran mengenai bagaimana caranya
kita menganalisa sebuah data, yang dimana banyak digunakan oleh para Data Analyst pemula untuk
melakukan EDA, handling missing value, dan juga mengatasi outlier. Data ini terus diperbarui dan
data yang terbaru dapat kita temukan pada Google Public Dataset. Data tersebut juga dapat kita akses
pada Google BigQuery.
Bahasa SQL yang digunakan sudah disiapkan, dan bagi kalian yang ingin menarik datanya
tersebut, dapat menggunakan query tersebut untuk menarik data langsung dari Google BigQuery.
Penjelasan mengenai bagaimana cara kita mengakses Google BigQuery menggunakan Python sudah
dijelaskan pada Bab 2 - Basic Python.
Pada contoh ini, kita akan membuat sebuah model forecast dengan menggunakan RNN
dengan menggunakan library PyTorch. Nantinya kita akan mencoba juga untuk membuat model ini
dengan menggunakan Tensorflow.

Menyiapkan Data

Kita akan menarik data dari Google BigQuery (GBQ) untuk mendapatkan data yang akan
kita coba untuk olah. Pada contoh ini, data telah tersedia dalam bentuk CSV, sehingga kalian bisa
langsung menggunakan data tersebut tanpa harus menarik dari GBQ. Perhatikan karena data tersebut
sangat besar, maka kita akan secara selektif memilih hanya beberapa kolom yang relevan untuk
digunakan, dan juga kita akan membatasi data yang kita ambil hanyalah data penjualan pada tahun
2022 dan 2023 saja. Pada saat modul ini ditulis, data terakhir diperbarui pada GBQ pada tanggal 30
Juli 2023.

Agar pembahasan ini lebih menarik dan kita mempunyai data untuk dibandingkan, pada
contoh ini kita akan menarik seluruh data pada tahun 2022, dan memisahkan data tersebut dengan
data pada tahun 2023.
64
 Kita akan mencoba untuk menggunakan data pada tahun 2022, untuk memprediksi total
penjualan pada 6 bulan pertama pada tahun 2023. Data yang akan kita gunakan hanyalah data yang
memuat tanggal, dan kita hanya mengolah data dimana nama kotanya adalah ‘Des Moines’. Nantinya
kita akan menggunakan data tahun 2023 yang kita miliki sebagai perbandingan. Namun perlu
diperhatikan bahwa pada contoh ini, kita sama sekali tidak akan menggunakan data 2023 dalam
model RNN kita, dan hanya digunakan untuk membandingkan hasil forecast kita saja. Perlu
diperhatikan juga bahwa pada umumnya pada data yang ada di industri, hal ini tidak umum terjadi,
dan biasanya kita harus melakukan forecast berdasarkan data terakhir yang kita miliki.

Ketika kita menjalankan sintaks di atas, kita dapat melihat bahwa jumlah data pada tahun
2022 ada 295 data.

Kita lihat bahwa jumlah baris yang ada pada data kita hanyalah 295. Kita mengetahui bahwa
data tersebut berisi data penjualan harian pada kota Des Moines, dan kita memiliki beberapa data
yang hilang pada beberapa hari (Dalam satu tahun memiliki 365 hari, seharusnya ada 365 baris). Kita
akan mencoba untuk mengisi data tersebut dengan nilai 0 agar kita memiliki data dengan nilai yang
lengkap.

65
 Kita akan membuat sendiri list berisi seluruh tanggal dari tanggal 1 Januari 2022 sampai 31
Desember 2022. List ini akan kita tampung dalam date_list. Kita menggunakan timedelta untuk
membantu kita menambah tanggal dengan interval 1 hari. Dengan ini, kita akan memiliki seluruh
tanggal pada tahun 2022. Kita akan membuat sebuah dataframe baru bernama dfs, yang akan memuat
seluruh tanggal kita. Kita akan merubah namanya menjadi sales_date dan juga kita akan
menggabungkan dfs tersebut dengan data df kita dengan menggunakan merge. Setelah data
digabungkan, kita akan memiliki data berjumlah 365 baris, dengan kolom total_sales yang tidak
memiliki tanggal awalnya akan berisikan nilai Null. Kita akan mengganti nilai Null tersebut dengan
0. Sehingga ketika kita menjalankan df_fixed tersebut yang merupakan penggabungan kedua
dataframe, kita mendapatkan data seperti berikut ini.

66
 Perhatikan bahwa pada data tersebut, kita memiliki data dengan pola naik turun yang lumayan
ekstrim. Kita akan memisahkan data pada 11 bulan pertama untuk digunakan sebagai train data, dan
menyisakan data 1 bulan terakhir untuk test data. Oleh karena itu, kita bisa memisahkan data tersebut
menjadi seperti berikut ini.

Kita menggunakan iloc dengan nomor indeks 334, yang menunjukkan data 11 bulan. Kita juga
dapat menggunakan cara lain dengan melakukan filter dimana data tersebut kurang dari tanggal 30
November (untuk train data) dan lebih dari 30 November (untuk test data).

67
 Dengan melihat pola data yang dihasilkan sebelumnya, kita memahami bahwa ada
pengulangan pola pada data yang kita miliki. Kita akan mencoba untuk melakukan forecast pada
train data, lalu melakukan validasi terhadap test data.

Melakukan Preprocessing terhadap data sebelum membuat model

Karena kita memiliki data dengan variasi nilai yang tinggi, kita akan melakukan preprocessing
dulu, dengan scaler yang kita pilih ada MinMaxScaler.

Dengan MinMaxScaler, kita menghilangkan rentang skala yang tinggi pada data asli kita, dan
kita membuat data kita hanya memiliki rentang nilai antara -1 dan 1. Ini sangat berguna untuk
menghindari adanya overfit pada saat kita melatih data kita. Setelah kita menuliskan scaler kita, kita
akan memasukkan train data kedalam scaler dengan fit_transform. Karena kita hanya memiliki
data dengan 1 kolom saja, maka kita menggunakan reshape untuk mengubah bentuknya menjadi (-
1,1) agar bisa dibaca oleh MinMaxScaler.

Kita dapat melihat bentuk dari scaled_train yang telah kita buat berikut ini.

68
 Apabila kita perhatikan 10 data pertama, bentuk dari scaled_train sekarang sudah memiliki
rentang nilai antara -1 sampai dengan 1. Bentuk data dari scaled_train sendiri masih berbentuk array
2 dimensi. Kita akan mengubah bentuk array 2 dimensi tersebut menjadi sebuah tensor. Untuk
mengubah bentuk scaled_train tersebut menjadi tensor, kita juga akan memanggil library torch yang
nantinya akan digunakan juga untuk pembentukan model RNN.

Kita menggunakan FloatTensor untuk mengubah bentuk array 2 dimensi menjadi sebuah
tensor. Kita juga menggunakan fungsi view(-1) untuk meratakan nilai data pada tensor tersebut. Kita
memasukkan hasil perubahan tersebut dalam variabel bernama train_tensor.
Setelah ini, kita akan membuat sebuah fungsi yang dapat mengambil data dalam bentuk batch.
Karena model RNN memerlukan data input yang berurutan untuk melakukan sebuah forecast, maka
kita akan membentuk data input menjadi batch. Batch yang akan kita buat memiliki ukuran 30,
sehingga kita akan memiliki sekitar 11 - 12 batch train_tensor. Kita akan melihat pada gambar
berikut ini, bagaimana cara kita mengubah data harian yang kita miliki menjadi sebuah data input
batch yang nantinya akan kita gunakan sebagai input pada model RNN.

69
 Pada fungsi batch yang kita buat di atas, dengan menuliskan jumlah window_size adalah 30,
maka tiap batch akan berisikan 30 data, yang berarti adalah jumlah data pada 1 bulan. Dengan total
data sebanyak 334 (jumlah data pada train data), kita akan memiliki sekitar 11 - 12 batch yang dapat
digunakan untuk input pada RNN. Kita juga akan menampilkan data berikutnya pada tiap batch,
sehingga hasil keluaran fungsi tersebut memiliki 2 atribut. Setelah ini kita akan membuat model
RNN yang digunakan dengan menggunakan LSTM.

Membuat Model LSTM

70
 Kita akan menginisialisasi variabel yang akan digunakan pada bagian __init__. Kita
menggunakan 100 hidden layer untuk model LSTM yang akan digunakan, dengan jumlah input dan
output adalah 1. Kita juga membuat sebuah layer yang terhubung, dengan menghubungkan model
LSTM dengan model linear antara hidden layer dan output. Kita juga akan menginisialisasikan nilai
h0 dan c0 yang digunakan sebagai input pada model LSTM dengan tensor bernilai 0 berukuran 1x1.
Setelah seluruh inisialisasi dibuat, kita membuat fungsi prediksi yang akan digunakan. Kita
hanya akan mengambil nilai terakhir dari hasil prediksi yang dilakukan model LSTM, karena kita
hanya membutuhkan nilai tersebut untuk prediksi nilai kedepannya. Setelah model tersebut dijalankan
dan tidak memiliki error, kita akan memasukkan model tersebut dalam variabel bernama model.

Kita juga akan membuat sebuah criterion yang digunakan sebagai loss function pada proses
pelatihan nantinya. Kita tidak lupa membuat sebuah optimizer yang dapat meningkatkan performa
dari model itu dengan menggunakan Adam Optimizer, dan juga menggunakan nilai parameter pada
model dan juga learning rate sebesar 0,001.

Isi dari model.parameters() berupa susunan layer yang kita buat pada model LSTM
sebelumnya. Kita dapat memanggil model.parameters untuk melihat susunan layer.

71
Melakukan Pelatihan Model

Setelah ini kita akan melakukan pelatihan terhadap model yang kita buat. Kita akan
menggunakan 100 episode pelatihan untuk melatih model kita.

Pada proses di atas, kita membuat sebuah variabel losses yang dapat menampung hasil dari
loss yang dihasilkan oleh model nantinya. Kita menggunakan library time dari Python untuk
mengukur lamanya waktu pelatihan model kita. Untuk tiap episode, kita akan memisahkan batch dan
juga hasil prediksi pada train data. Pada awal pelatihan, kita akan memasang nilai gradien berada
pada posisi 0 dengan optimizer.zero_grad(). Kita juga menyatakan h0 dan c0 dalam model.hidden
dengan tensor berukuran 1x1 dengan nilai 0. Setelah itu, kita melakukan prediksi dan menghitung
nilai loss dengan menggunakan fungsi criterion yang kita buat sebelumnya. Tidak lupa kita juga
menuliskan loss.backward() untuk backpropagation dan menjalankan optimizer satu langkah dengan
optimizer.step(). Kita akan mengeluarkan hasil pencatatan loss tiap 10 episode pelatihan dan juga
menampilkan lamanya waktu yang dibutuhkan pada proses pelatihan model tersebut. Perhatikan
hasilnya berikut ini.

72
 Jumlah waktu yang kita butuhkan untuk melakukan proses pelatihan adalah 69,99 detik. Kita
lihat pada tiap episode, nilai loss cenderung berkurang sampai pada episode 60, dan memiliki
beberapa peningkatan setelahnya. Kita dapat menggunakan variabel losses yang sebelumnya kita
buat, untuk dapat menampilkan hasil loss tersebut dalam bentuk grafik. Perhatikan sintaks berikut ini.

Kita lihat bahwa pada model yang kita buat, kita memiliki nilai loss yang bervariasi dan
cenderung tidak stabil, namun nilai loss cenderung turun semakin tinggi episode yang dilakukan oleh
model. Setelah ini, kita akan mencoba untuk melakukan forecast 6 bulan kedepan sampai bulan Juni
2023.

73
Melakukan Forecast untuk 6 Bulan Kedepan

Karena data yang kita miliki merupakan data harian, maka untuk memprediksi data sampai
akhir Juni 2023, maka akan ada 181 data hari sampai tanggal 30 Juni 2023. Kita akan memasukkan
informasi ini dalam variabel periode. Untuk melakukan prediksi sampai Juni 2023, maka kita akan
melakukan prediksi terhadap data pada Januari 2023 terlebih dahulu. Kita akan membutuhkan
informasi 1 bulan terakhir pada train data, dimana informasi ini kita dapatkan dari mengambil 30 data
terakhir pada train_tensor. Untuk tiap periode, kita akan melakukan iterasi untuk memprediksi 1
nilai berikutnya, lalu nilai tersebut akan kita tambahkan pada variabel list preds yang kita buat.
Proses iterasi ini akan terus berulang sampai pada periode ke 181, atau sampai tanggal 30 Juni 2023.
Apabila kita melihat data preds hasil prediksi secara sekilas, data tersebut akan berbentuk seperti
pada gambar berikut.

74
 Data hasil prediksi tersebut masih berbentuk data yang ternormalisasi. Kita akan
mengembalikan data normalisasi tersebut menjadi bentuk data sebenarnya. Perhatikan gambar berikut
ini.

Kita menggunakan fungsi dari scaler yang kita miliki yaitu inverse_transform. Kita juga
menggunakan fungsi reshape(-1,1) untuk mengubah bentuknya menjadi bentuk yang bisa diolah oleh
NumPy. Apabila kita cek hasilnya, maka kita mendapatkan nilai yang kurang lebih mirip dengan nilai
sebenarnya. Perhatikan bahwa hasil dari variabel prediction ini berurutan dan mewakili nilai prediksi
dari tanggal 1 Januari 2023 yang kita lakukan prediksi sampai tanggal 30 Juni 2023. Kita akan
memasangkan data tersebut dengan tanggalnya masing - masing untuk membentuk sebuah dataframe
yang bisa kita bandingkan pada saat melakukan validasi dengan data tahun 2023 yang kita ambil dari
BigQuery sebelumnya.

Melakukan Validasi Data dengan Tahun 2023

75
 Setelah rentang waktu tersebut terbentuk dan kita masukkan dalam sebuah list, kita dapat
membuat sebuah dataframe baru yang berisikan hasil forecast tersebut. Kita menggunakan perintah
pd.Dataframe dari pandas untuk membuat sebuah dataframe baru.

Setelah ini, kita akan mencoba untuk melakukan validasi terhadap data tahun 2023 yang asli
yang kita dapatkan sebelumnya dengan menggunakan BigQuery. Kita akan mencoba untuk membaca
data dengan cara yang sama ketika kita membaca data tahun 2022 dengan menggunakan pd.read_csv
dengan data 2023 yang telah kita simpan di Google Drive. Perhatikan bahwa data tersebut tidak berisi
181 baris, hanya 137 baris. Ini berarti menandakan bahwa tidak setiap hari memiliki penjualan pada
kota Des Moines.

76
 Kita akan menggabungkan dataframe yang berisikan nilai forecast dan juga dataframe yang
berisikan data asli. Kita akan menggunakan perintah pd.merge pada pandas untuk menggabungkan
kedua dataframe ini.

Ketika kita mengeluarkan hasil dataframe df_combine, kita akan melihat data hasil forecast
dengan data asli dengan tanggalnya masing - masing.

Perhatikan bahwa data pada tanggal 1 Januari 2023 tidak tertera pada data asli, sehingga
berdasarkan sintaks yang kita buat, kita akan mengisikan nilai tersebut dengan menggunakan fungsi
pandas fillna(0) untuk mengubah paksa seluruh nilai yang hilang menjadi 0. Untuk membandingkan
nilai forecast dengan nilai sebenarnya, kita dapat menggambarkan kedua data tersebut dengan
menggunakan matplotlib. Perhatikan sintaks berikut.

77
 Apabila kita perhatikan sekilas, nilai prediksi yang kita buat mengikuti pola dan tren osilasi
yang dihasilkan oleh data sebenarnya. Kita juga dapat melihat bahwa ada beberapa nilai forecast yang
menghasilkan nilai negatif, dimana ada beberapa hasil yang melewati angka 0. Untuk lebih
memperjelas hasil tersebut, kita akan melihat data bulan Januari, dimana data tersebut masih
merupakan hasil prediksi dari data awal yang kita gunakan.

78
 Dari hasil prediksi yang dihasilkan, kita melihat pola tren yang mirip dengan data sebenarnya,
namun banyak nilai sales yang tidak sesuai dengan data sebenarnya. Kita mencoba untuk melihat data
bulan Januari karena bulan ini merupakan data yang terdekat dengan train data yang kita miliki
sebelumnya ketika kita melatih model. Pada bagian pembahasan teori mengenai RNN, kita
mengetahui bahwa kita akan menggunakan data hasil prediksi tersebut untuk dapat melakukan
forecast untuk batch berikutnya. Dengan konsep tersebut, data pada batch terakhir memiliki
kemungkinan untuk error yang lebih besar. Kita akan coba untuk melihat data yang dihasilkan pada
bulan Juni 2023.

Untuk melihat hasil error yang dihasilkan antara nilai forecast dengan nilai sebenarnya, kita
akan coba untuk melihat seberapa besar nilai error keduanya. Kita akan menggunakan library scikit-
learn disini dan menggunakan perhitungan error metrics Mean Absolute Error, Mean Squared
Error, dan Root Mean Squared Error untuk menghitung nilai error dari kedua data ini.

79
 Kita akan membandingkan nilai dari tiap metrics tersebut dengan nilai rata - rata (Mean) dari
data.

Perhatikan bahwa nilai error yang kita miliki relatif lebih besar dibandingkan dengan nilai rata
- rata dari data kita sebenarnya. Ini berarti bahwa model yang kita miliki masih membutuhkan
beberapa parameter yang bisa dikembangkan, agar memiliki hasil prediksi yang lebih baik. Kita bisa
memperpanjang episode yang digunakan untuk pelatihan, ataupun mengubah parameter optimizer
yang kita gunakan, dan juga mungkin menggunakan jumlah batch yang berbeda untuk melakukan
pelatihan terhadap model LSTM kita.
Pada kasus sebenarnya, kita mungkin tidak bisa membandingkan hasil forecast dengan hasil
sebenarnya, karena kita tidak memiliki data sebenarnya sebagai pembanding karena hal tersebut
terjadi di masa depan. Namun, untuk membuktikan apakah model yang kita hasilkan akurat atau
tidak, kita bisa membagi data tersebut menjadi batch yang lebih kecil, agar kita bisa melakukan
validasi terhadap data yang kita miliki.
Untuk kasus forecasting, kita mungkin akan memiliki nilai yang lebih akurat apabila kita
membuat model time-series forecasting, dengan model lain seperti ARIMA dan SARIMA yang lebih
efektif dalam melakukan forecast dibandingkan dengan model RNN dan LSTM, namun kita tidak
akan membahas penggunaan time-series forecasting pada pembahasan Deep Learning ini. Pada
bagian selanjutnya, kita akan mencoba untuk membuat model RNN dan LSTM dengan menggunakan
Tensorflow dan Keras, dan mencoba untuk membandingkan performanya dengan yang telah kita
buat menggunakan PyTorch.

80
Study Case : Prediksi Penjualan Liquor pada Iowa (Tensorflow dan Keras)

Pada pembahasan kali ini, kita akan mencoba untuk mengaplikasikan pembuatan model RNN
dan LSTM dengan menggunakan data penjualan liquor dari negara Iowa. Data ini sama dengan data
yang sebelumnya kita gunakan untuk membuat forecast dengan menggunakan library PyTorch pada
bagian sebelumnya. Kita akan mencoba untuk membandingkan bagaimana kita membuat model
dengan menggunakan Tensorflow dan Keras untuk mendapatkan hasil forecasting, sama seperti yang
kita lakukan pada pembahasan PyTorch sebelumnya.
Pada bagian ini, kita akan membuat generator yang akan kita gunakan untuk memanggil data
tiap batch. Generator yang kita gunakan akan memanggil data dengan rentang waktu per bulan.

Menyiapkan Data

Kita akan menarik data dari Google BigQuery (GBQ) untuk mendapatkan data yang akan
kita coba untuk olah. Pada contoh ini, data telah tersedia dalam bentuk CSV, sehingga kalian bisa
langsung menggunakan data tersebut tanpa harus menarik dari GBQ. Perhatikan karena data tersebut
sangat besar, maka kita akan secara selektif memilih hanya beberapa kolom yang relevan untuk
digunakan, dan juga kita akan membatasi data yang kita ambil hanyalah data penjualan pada tahun
2022 dan 2023 saja. Pada saat modul ini ditulis, data terakhir diperbarui pada GBQ pada tanggal 30
Juni 2023.

Sama seperti pembahasan pada pembuatan model RNN dan LSTM dengan menggunakan
PyTorch sebelumnya, agar pembahasan ini lebih menarik dan kita mempunyai data untuk
dibandingkan, pada contoh ini kita akan menarik seluruh data pada tahun 2022, dan memisahkan data
tersebut dengan data pada tahun 2023. Namun perlu diingat bahwa pada kasus sebenarnya, kita tidak
mungkin untuk melakukan hal ini karena biasanya kita tidak tahu data yang dihasilkan di masa depan
akan berbentuk dan bernilai seperti apa.

81
 Kita akan mencoba untuk menggunakan data pada tahun 2022, untuk memprediksi total
penjualan pada 6 bulan pertama pada tahun 2023. Data yang akan kita gunakan hanyalah data yang
memuat tanggal, dan kita hanya mengolah data dimana nama kotanya adalah ‘Des Moines’. Nantinya
kita akan menggunakan data tahun 2023 yang kita miliki sebagai perbandingan. Namun perlu
diperhatikan bahwa pada contoh ini, kita sama sekali tidak akan menggunakan data 2023 dalam
model RNN kita, dan hanya digunakan untuk membandingkan hasil forecast kita saja. Perlu
diperhatikan juga bahwa pada umumnya pada data yang ada di industri, hal ini tidak umum terjadi,
dan biasanya kita harus melakukan forecast berdasarkan data terakhir yang kita miliki.

Ketika kita menjalankan sintaks di atas, kita dapat melihat bahwa jumlah data pada tahun
2022 ada 295 data.

Kita lihat bahwa jumlah baris yang ada pada data kita hanyalah 295. Kita mengetahui bahwa
data tersebut berisi data penjualan harian pada kota Des Moines, dan kita memiliki beberapa data
yang hilang pada beberapa hari (Dalam satu tahun memiliki 365 hari, seharusnya ada 365 baris). Kita
akan mencoba untuk mengisi data tersebut dengan nilai 0 agar kita memiliki data dengan nilai yang
lengkap.

82
 Kita akan membuat sendiri list berisi seluruh tanggal dari tanggal 1 Januari 2022 sampai 31
Desember 2022. List ini akan kita tampung dalam date_list. Kita menggunakan timedelta untuk
membantu kita menambah tanggal dengan interval 1 hari. Dengan ini, kita akan memiliki seluruh
tanggal pada tahun 2022. Kita akan membuat sebuah dataframe baru bernama dfs, yang akan memuat
seluruh tanggal kita. Kita akan merubah namanya menjadi sales_date dan juga kita akan
menggabungkan dfs tersebut dengan data df kita dengan menggunakan merge. Setelah data
digabungkan, kita akan memiliki data berjumlah 365 baris, dengan kolom total_sales yang tidak
memiliki tanggal awalnya akan berisikan nilai Null. Kita akan mengganti nilai Null tersebut dengan
0. Sehingga ketika kita menjalankan df_fixed tersebut yang merupakan penggabungan kedua
dataframe, kita mendapatkan data seperti berikut ini.

83
 Perhatikan bahwa pada data tersebut, kita memiliki data dengan pola naik turun yang lumayan
ekstrim. Kita akan memisahkan data pada 11 bulan pertama untuk digunakan sebagai train data, dan
menyisakan data 1 bulan terakhir untuk test data. Oleh karena itu, kita bisa memisahkan data tersebut
menjadi seperti berikut ini.

Kita menggunakan iloc dengan nomor indeks 334, yang menunjukkan data 11 bulan. Kita juga
dapat menggunakan cara lain dengan melakukan filter dimana data tersebut kurang dari tanggal 30
November (untuk train data) dan lebih dari 30 November (untuk test data).

84
 Dengan melihat pola data yang dihasilkan sebelumnya, kita memahami bahwa ada
pengulangan pola pada data yang kita miliki. Kita akan mencoba untuk melakukan forecast pada
train data, lalu melakukan validasi terhadap test data.

Melakukan Preprocessing terhadap data sebelum membuat model

Karena kita memiliki data dengan variasi nilai yang tinggi, kita akan melakukan preprocessing
dulu, dengan scaler yang kita pilih ada MinMaxScaler.

Dengan MinMaxScaler, kita menghilangkan rentang skala yang tinggi pada data asli kita, dan
kita membuat data kita hanya memiliki rentang nilai antara 0 dan 1. Ini sangat berguna untuk
menghindari adanya overfit pada saat kita melatih data kita. Setelah kita menuliskan scaler kita, kita
akan memasukkan train data kedalam scaler dengan fit_transform, dan hanya menerapkan
transform pada test data, untuk menghindari agar train data tidak melihat isi dari test data.

Kita dapat melihat bentuk dari train data dan test data yang telah diubah skalanya dengan
scaler kita.
85
Membuat Model RNN

Sebelum kita akan membuat model RNN, kita akan terlebih dahulu memanggil
TimeseriesGenerator. Fungsi ini ada didalam tensorflow.keras.preprocessing.sequence. Untuk
memahami penggunaan fungsi ini, mari kita lihat sedikit dokumentasinya.

Parameter data merupakan data yang akan kita gunakan untuk diproses. Dalam data ini harus
menunjukkan adanya urutan, dalam kasus kita, merupakan index ‘sales_date’. Targets merupakan
nilai data dari timestep yang kita tentukan, dalam kasus ini, kita menggunakan data yang sama.
Length merupakan panjang data pada tiap sample yang digunakan untuk proses pelatihan. Parameter
yang akan kita gunakan yang lainnya adalah batch_size, yang berisi jumlah batch sesuai length yang
akan kita tampilkan. Dengan keterangan tersebut, maka kita bisa membuat generator kita seperti
pada contoh berikut ini.

86
 Kita menuliskan length = 12 dimana tiap sample akan memilih hanya 12 data tiap melakukan
pelatihan. Angka ini dapat kita sesuaikan dengan kebutuhan. Kita juga menuliskan batch = 1 untuk
menunjukkan bahwa kita menginginkan generator memberikan output untuk 1 bulan kedepan (akan
mengeluarkan 30 data sebanyak 1 kali).

Mari kita bandingkan antara hasil X dengan scaled_train yang kita buat sebelumnya.

87
 Generator yang kita buat akan menampilkan 12 data yang sama dengan scaled_train yang
kita buat. Kita juga akan melihat nilai y yang dihasilkan generator, yang merupakan langkah
selanjutnya. Apabila benar, kita seharusnya mendapatkan data pada urutan berikutnya pada
scaled_train sama dengan nilai y.

Kita telah memahami bagaimana cara kerja generator, dan juga apa yang dihasilkan dari
generator tersebut. Sekarang, kita akan mencoba untuk membuat model RNN dari generator yang
telah kita buat. Untuk itu, kita akan membuat neural network seperti yang kita lakukan pada contoh
sebelumnya.

Untuk membuat model RNN, kita memanggil Sequential dari tensorflow.keras.models sama
seperti yang kita lakukan biasanya, lalu dari layers, kita akan memanggil fungsi Dense dan LSTM.
Kita juga menuliskan n_features = 1 karena kita hanya memiliki 1 fitur (total_sales) saja. Untuk
membuat sebuah LSTM, kita dapat menuliskan LSTM(jumlah_neuron,activation,input_shape).
Parameter jumlah neuron ini akan menentukan ada berapa banyak neuron dalam LSTM tersebut.
Parameter activation ini akan menuliskan activation function yang kita ingin gunakan. Parameter
input_shape ini akan menuliskan ukuran input yang akan kita masukkan pada LSTM ini. Setelah
membuat LSTM, kita akan menuliskan Dense untuk menyatakan output. Karena kita akan bekerja
dengan data continuous, kita menggunakan Adam Optimizer, lalu menggunakan Mean Squared
Error sebagai pencatatan loss functionnya.

88
 Kita bisa menggunakan model.summary() untuk melihat bagaimana model kita terbentuk.
Kita melihat bahwa total parameter yang dihasilkan dari LSTM tersebut sendiri sejumlah 40.800 dan
model Dense kita yaitu 101. Dengan jumlah parameter sebanyak ini, kita mungkin akan memerlukan
waktu yang lebih lama untuk melatih model kita. Kita akan menggunakan EarlyStopping untuk
menghentikan proses training apabila loss kita meningkat. Lalu kita juga akan membuat generator
untuk test data, lalu kita akan memasukkan seluruhnya kedalam model yang kita buat. Perhatikan
penulisan sintaksnya berikut ini.

Sintaks di atas merupakan sintaks untuk membuat sebuah EarlyStopping dan juga membuat
sebuah generator pada scaled_test. Ingat bahwa kita menggunakan length = 1 dan bukan 12 seperti
pada scaled_train, karena kita hanya akan menampilkan 1 data pada tiap prediksi. Setelah ini kita
akan memasukkan parameter tersebut kedalam model, dan melatih model tersebut pada 100 episode.

89
 Kita lihat hasil dari pelatihan pada tiap episode.

Pada proses pelatihan tersebut, kita selesai pada episode ke 14 dari 100, yang merupakan
cukup cepat.

Melakukan Validasi

Kita akan coba untuk melakukan evaluasi dari proses pelatihan tersebut. Kita akan coba untuk
memvisualisasikan nilai loss tersebut.

90
 Perhatikan bahwa val_loss kita meningkat semenjak episode ke - 3, lalu karena nilai patience
kita adalah 5, maka proses pelatihan kita akan berhenti pada episode ke -13 karena sejak episode ke -
8 (nilai val_loss terendah), 5 episode setelah itu tidak bisa lagi lebih rendah dari nilai val_loss pada
episode ke -8.
Setelah ini kita akan mencoba untuk melakukan prediksi pada satu time step kedepan.
Perhatikan sintaks berikut ini.

Perhatikan sintaks di atas. Kita membuat sebuah list kosong untuk menampung hasil prediksi
kita. Kita juga akan membuat evaluasi yang mengambil 12 data terakhir pada scaled_train. Dengan
menggunakan reshape, kita mengubah bentuk batch tersebut menjadi bentuk data yang bisa diterima
oleh RNN.
Disini kita akan melakukan iterasi untuk melakukan prediksi 1 time step kedepan. Hasil
prediksi tersebut akan kita simpan kedalam list test_prediction yang kita buat sebelumnya. Baris
sintaks terakhir merupakan baris yang mungkin sulit dipahami. Pada baris terakhir, kita akan
memperbarui batch kita, dimana kita hanya mengambil data pada indeks ke 1 (ingat bahwa kita
memulai data pada indeks 0), sehingga kita membuang data pertama, lalu menambahkan data hasil
prediksi tersebut kedalam batch tersebut, untuk dilakukan prediksi pada time step selanjutnya.
Ketika kita menjalankan sintaks tersebut, kita akan melihat proses prediksi yang dilakukan
oleh model.

91
 Setelah ini, kita akan mengembalikan nilai prediksi kita dengan skala yang sebenarnya. Ingat
bahwa sebelumnya kita menggunakan MinMaxScaler untuk mengubah skala dari seluruh data kita.

Kita akan membandingkan nilai hasil prediksi dengan nilai pada test data kita.

Kita akan coba untuk membuat visualisasi sederhana dari test data tersebut untuk melihat
apakah hasil prediksi tersebut mirip dengan test data yang kita miliki.

92
 Perhatikan gambar tersebut. Kita melihat bahwa secara tren, model yang kita miliki sudah
dapat memprediksi tren yang terjadi pada test data bulan Desember, walaupun memang secara nilai
banyak yang tidak tepat. Apabila kita akan menggunakan model ini untuk forecast, kita masih
mungkin untuk mendapatkan data yang sesuai dengan tren, walaupun mungkin kita tidak tahu karena
data tersebut belum terbentuk, namun ini merupakan sebuah langkah awal yang baik. Apabila kita
sudah puas dengan hasil model tersebut dan parameter yang telah digunakan sebelumnya, kita bisa
membuat ulang model kita dengan menggunakan seluruh data yang kita miliki menjadi sebuah data
input. Perhatikan pembuatan sintaksnya secara menyeluruh berikut ini.

93
 Kita membuat ulang model tersebut dengan kali ini menggunakan keseluruhan data tahun
2022 sebagai sebuah train data. Langkah - langkah selanjutnya sama persis seperti yang kita lakukan
sebelumnya ketika kita mencari parameter. Hal yang berbeda disini adalah jumlah episode yang kita
tentukan. Perhatikan bahwa pada proses pelatihan kita sebelumnya, kita menggunakan
EarlyStopping() dan mengetahui bahwa setelah episode ke - 8, nilai val_loss kita meningkat dan
mengakibatkan proses pelatihan berhenti pada episode ke - 13. Ketika kita melatih keseluruhan data,
kita menganggap menggunakan EarlyStopping merupakan sebuah proses yang “curang” bagi
model, karena seharusnya kita membiarkan model tersebut terus dilatih tanpa diberitahu, pada episode
ke berapa model tersebut akan memiliki nilai val_loss yang tidak memuaskan.
Karena pada proses uji coba kita sebelumnya kita tahu bahwa nilai loss terendah terjadi pada
episode ke - 8, hanya hal ini yang bisa kita beritahu pada model, sehingga kita menuliskan epochs =
8. Kita tidak memasang EarlyStopping() supaya kita memberikan perlakuan yang adil kepada model,
dan tidak memberhentikannya di tengah jalan. Setelah kita membiarkan model tersebut melakukan
pelatihan pada ke - 8 episode tersebut, kita akan mendapatkan hasil berikut ini.

94
 Setelah proses pelatihan tersebut selesai, kita akan membuat fungsi yang digunakan untuk
forecast. Perhatikan sintaks berikut ini.

Kita menuliskan jumlah periode = 181, yang menunjukkan kita akan memprediksi 176 hari
kedepan, dimana 176 ini adalah jumlah hari yang dilewati dari tanggal 1 Januari 2023 sampai 30 Juni
2023 (sesuai tanggal terakhir pada GBQ). Kita akan menjalankan sintaks di atas, lalu kita akan
melihat bagaimana proses model tersebut melakukan forecast pada data yang kita belum tahu
kedepannya.

95
 Setelah model yang kita buat telah selesai melakukan forecast, kita akan coba untuk mengecek
hasilnya.

Apakah data tersebut akurat, kita tidak mengetahuinya. Pada studi kasus sebenarnya, kita tidak
akan mengetahui apakah jumlah sales tersebut akurat atau tidak. Namun pada studi kasus ini,
kebetulan kita memiliki sebuah data pembanding yang dapat digunakan untuk mengecek performa
model kita. Kita akan mencoba untuk membandingkan nilai tersebut dengan nilai pada data 2023
yang kita ambil sebelumnya dari GBQ. Sebelum itu, kita akan membentuk hasil forecast tersebut
menjadi sebuah dataframe agar lebih enak untuk dilihat.

96
 Kita akan membuat sebuah date_range yang berisikan tanggal sebanyak jumlah periode yang
kita miliki. Dengan menuliskan 176 sebagai jumlah periode dan start_date adalah 1 Januari 2023,
kita akan membentuk sebuah list berisikan tanggal dari tanggal 1 Januari 2023 sampai 25 Juni 2023.
List ini yang akan kita gunakan untuk membentuk dataframe forecast kita.

Sekarang kita telah memiliki dataframe yang berisikan data forecast kita. Kita sekarang akan
coba untuk membaca data tahun 2023 yang kita ambil dari GBQ sebelumnya, lalu kita akan
membandingkannya dengan data forecast kita.

97
 Dengan cara yang sama ketika kita menyiapkan data 2022, kita akan menggabungkan kedua
dataframe tersebut.

Kita akan membuat dataframe bernama forecast_reset untuk melakukan reset pada index
sehingga kita memiliki kolom tambahan yang bernama index. Nama kolom tersebut akan kita ubah
menjadi sales_date, karena memang kolom tersebut merupakan kolom yang kita buat dari fungsi
date_range sebelumnya. Pada dataframe forecast_reset, kita akan mengubah tipe data tersebut
menjadi string, agar sama seperti pada tipe data pada data 2023 yang kita miliki (string) sehingga bisa
kita gabungkan. Kita akan menggabungkan forecast_reset dengan df_2023 menjadi sebuah
dataframe baru yaitu df_combine, lalu kita akan kembali memasangkan kolom sales_date menjadi
index, lalu kita akan mengisi seluruh nilai NaN menjadi 0, karena pastinya ada beberapa tanggal di
data 2023 yang kosong. Setelah itu, ketika kita memanggil df_combine, kita dapat melihat sekilas
datanya seperti pada gambar yang tertera di atas. Untuk memastikan nilai tersebut dan
membandingkan nilai forecast dengan nilai sebenarnya, kita akan menampilkan visualisasi untuk
melihat seberapa jauh perbedaannya.

98
 Ketika kita menampilkan perbandingannya dalam visualisasi, kita kesulitan untuk melihat
seluruhnya, namun apabila kita lihat sekilas, secara tren, hasil forecast kita mirip dengan data asli,
namun secara nilai data, banyak nilai yang mungkin meleset. Kita akan coba untuk perkecil index kita
dengan hanya menampilkan visualisasi selama bulan Januari saja.

99
 Kita memiliki tren yang serupa antara data forecast dengan data asli, namun banyak nilai yang
memang tidak sesuai dari data forecast tersebut. Untuk mengecek seberapa jauh nilai error hasil
forecast dengan data 2023 sebenarnya, kita bisa menggunakan Mean Absolute Error, Mean
Squared Error, dan Root Mean Squared Error untuk melakukan pengecekan error.

Perhatikan bahwa nilai error kita bervariasi antara MAE, MSE, dan RMSE. Nilai ini
merupakan nilai yang kurang baik, yang berarti model kita tidak terlalu baik untuk melakukan
forecast pada data tersebut. Kita akan mencoba untuk mengecek data pada bulan Juni 2023.

100
 Pada kasus sebenarnya, kita tidak akan mengetahui apakah model kita dapat melakukan
forecast dengan baik. Untungnya, pada kasus ini, kita memiliki sebuah data yang dapat digunakan
sebagai pembanding, dan ketika dibandingkan, kita tidak mendapatkan hasil yang memuaskan.
Sebagai kesimpulan, kita kemungkinan dapat menggunakan metode lain yang digunakan
untuk memecahkan masalah yang berkaitan dengan waktu (time-series data) dengan menggunakan
metode seperti ARIMA atau SARIMA, agar mendapatkan hasil forecast yang lebih akurat. Namun,
walaupun kita tidak mendapatkan hasil error yang baik, namun kita dapat mengambil kesimpulan
bahwa metode RNN yang telah kita pelajari sebelumnya dapat digunakan untuk membuat sebuah
forecast, dan juga walaupun nilainya banyak yang tidak sesuai, model kita berhasil untuk membuat
sebuah forecast untuk tren yang terjadi dari bulan Januari 2023 sampai Juni 2023.

101
Autoencoder
Autoencoder merupakan bagian terakhir yang akan kita bahas pada materi Deep Learning
ini. Pada materi sebelumnya pada pembahasan ANN ataupun RNN, kita telah melihat bagaimana
metode neural network ini dapat bekerja dengan menggabungkannya dengan beberapa metode dan
library yang kita gunakan pada supervised learning. Autoencoder merupakan salah satu pembahasan
pada Deep Learning yang akan membahas bagaimana kita menerapkan metode neural network ini
pada metode dan library yang kita gunakan pada unsupervised learning.
Pada Autoencoder, fokus yang akan kita lakukan adalah kita menerapkan neural network
untuk dimensionality reduction dan juga noise removal. Ketika kita melakukan pelatihan neural
network, terkadang pada beberapa model, kita akan menggunakan data historikal dengan sebuah label.
Hal ini menjadi unik karena kita mengetahui bahwa unsupervised learning tidak memiliki sebuah
label, dan hanya berupa kumpulan fitur saja. Namun, pada saat kita menggunakan model
Autoencoder ini untuk diaplikasikan pada data sebenarnya, kita tidak akan bisa menggunakan
metrics yang digunakan untuk evaluasi, karena pada test data tersebut, kita tidak memiliki label.
Karena pada proses pelatihan kita terkadang menggunakan label, dan pada proses pengujian kita
menggunakan data yang tidak memiliki label, maka hal ini menjadi unik bagi Autoencoder, karena
menggunakan bentuk data yang berbeda. Oleh karena itu, aplikasi dari Autoencoder ini sering juga
disebut sebagai semi-supervised learning.

Teori
Autoencoder memiliki konsep yang sangat sederhana, dan akan terkesan seperti model neural
network dengan banyak perceptron seperti yang kita kenal pada ANN. Autoencoder pada prinsipnya
akan mereplikasi jumlah neuron yang ada pada input sama dengan jumlah neuron pada output.
Berikut ini merupakan contoh dari Autoencoder.

102
 Dengan konsep di atas, hidden layer yang kita miliki harus mampu untuk menghasilkan
jumlah output yang sama seperti input yang diterima. Oleh karena itu, penting bagi hidden layer
untuk dapat mempelajari fitur mana yang berperan penting dari input, agar dapat direplikasi pada
output. Hidden layer yang berada paling tengah akan mempelajari kombinasi terpenting dari fitur
aslinya.
Disini kita mendesain dimensi dari input 8 dimensi menjadi 3 dimensi. Disini terjadi
pengurangan jumlah dimensi sehingga pada hidden layer yang terdalam, kita hanya memiliki 3
dimensi. Perhatikan bahwa konsep berikut ini mirip dengan konsep pada Principal Component
Analysis (PCA) yang kita pelajari pada unsupervised learning. Ingat bahwa pada PCA, kita tidak
memilih sebagian dari fitur, tapi kita mengambil seluruh fitur dan mengubahnya agar menjadi
representasi dari dimensi yang lebih rendah.
Autoencoder bekerja dengan membaginya menjadi 2 tahap, yaitu proses encoder dan proses
decoder. Proses encoder akan menurunkan jumlah dimensi yang terjadi pada bagian input, sehingga
hidden layer akan dapat mengambil kombinasi dari fitur input tersebut. Proses decoder akan bekerja
sebaliknya, dimana proses ini akan mengembalikan jumlah dimensi yang telah direduksi agar kembali
memiliki dimensi yang sama seperti input pada bagian output. Berikut merupakan ilustrasi dari
encoder dan decoder.

103
 Karena kita ingin mengurangi jumlah dimensi, maka kita akan melakukan proses pelatihan
pada bagian encoder. Salah satu aplikasi dari dimensionality reduction ini biasanya adalah untuk
melakukan kompresi data.

Studi Kasus - Autoencoder untuk Data MNIST (PyTorch)

Pada bagian ini, kita akan berfokus untuk menggunakan autoencoder untuk mencoba
merekonstruksi ulang sebuah gambar output yang mirip dengan gambar inputnya. Dengan konsep
demikian, maka decoder bisa melakukan rekonstruksi ulang dari gambar input yang diberikan pada
bagian encoder berdasarkan informasi yang didapat dari hidden layer. Pada contoh autoencoder ini,
kita akan menggunakan dua cara, yaitu dengan menggunakan library PyTorch dan juga dengan
menggunakan library tensorflow dan keras. Pada bagian pertama, kita akan mencoba untuk
menggunakan library PyTorch terlebih dahulu. Data yang akan kita gunakan untuk percobaan ini
adalah data MNIST (Modified National Institute of Standards and Technology database), yaitu
merupakan sebuah gambar angka yang terbuat dari tulisan tangan yang disimpan dalam database.
Data ini dapat kita akses dengan menggunakan library dari PyTorch. Kita akan menyiapkan datanya
terlebih dahulu sebelum memulai untuk membuat model PyTorch.

104
Menyiapkan data

Untuk percobaan autoencoder ini kita akan menggunakan data MNIST. Data tersebut dapat
kita akses dari library PyTorch dan sudah disediakan untuk kebutuhan eksperimen. Kita akan
memanggil beberapa library yang digunakan dalam percobaan ini.

Kita menggunakan library torchvision untuk memanggil dataset berupa gambar yang
tersimpan pada library torch. Kita juga menggunakan fungsi transforms untuk membantu kita
mengubah data gambar ini menjadi sebuah tensor. Fungsi DataLoader kita gunakan untuk
memanggil data kita menjadi sebuah batch. Kita juga akan memanggil fungsi confusion_matrix dari
library scikit-learn untuk menghitung nilai akurasi yang dihasilkan dari prediksi yang nanti akan kita
lakukan dengan menggunakan PyTorch.
Setelah kita memanggil library yang dibutuhkan, kita akan memanggil fungsi transforms
untuk mengubah dataset yang akan kita panggil nanti menjadi tensor, lalu kita akan mendownload
data tersebut dalam folder Root.

Pada fungsi datasets, kita akan memberikan beberapa parameter seperti root yang merupakan
lokasi dimana kita akan menempatkan dataset tersebut, lalu download untuk opsi apakah kita ingin
mendownload file tersebut pada lokal komputer kita. Dengan opsi train = True, kita ingin
mendownload data yang sudah dilatih sebelumnya oleh PyTorch, sehingga kita tidak perlu melatih
data tersebut. Kita juga menuliskan transforms untuk mengubahnya menjadi tensor.

105
 Apabila kita ingin mengecek dimana PyTorch mendownload data tersebut pada Google
Colab, kita bisa melihat lokasi folder Data tersebut dengan melihat lokasi pada Files pada Google
Colab.

Ketika kita cek variabel train_data yang kita buat sebelumnya, kita dapat melihat informasi
mengenai data yang telah kita download.

Kita lihat bahwa kita memiliki jumlah data MNIST sebanyak 60.000 data, dimana keseluruhan
data tersebut telah dilakukan pelatihan sebelumnya. Kita akan mengecek tipe data dari train_data
tersebut.

Perhatikan bahwa tipe data train_data merupakan MNIST. Kita akan melihat bentuk dari
train_data tersebut. Kita akan mencoba mengeluarkan hanya data pada index pertama. Perhatikan
gambar berikut.

106
 Perhatikan bahwa isi dari data pada index pertama merupakan kumpulan tensor beserta label
dari gambar tersebut. Pada data gambar, angka - angka yang berada disini mewakili nilai pixel dari
gambar tersebut. Nilai pixel merupakan sebuah nilai yang mewakili intensitas dan warna dari sebuah
titik pada gambar tersebut, yang biasanya memiliki rentang nilai antara 0 - 255. Nilai yang kita lihat
pada gambar telah dinormalisasi sehingga rentangnya menjadi antara 0 sampai 1. Kita akan
mempelajari mengenai pixel dan teori gambar ini lebih lanjut pada Bab 5 - Computer Vision.
Pada data MNIST, ukuran dari gambar tersebut adalah 1 x 28 x 28. Ukuran ini menyatakan
dimensi dari gambar tersebut, dimana pada gambar MNIST angka 1 ini merupakan jumlah color
channel, sedangkan ukuran 28 merupakan kolom pixel, lalu 28 berikutnya merupakan jumlah baris
pixel.

107
 Dengan menggunakan matplotlib, kita bisa melihat seperti apa bentuk dari tensor tersebut
apabila kita visualisasikan.

Apabila kita lihat label dari gambar tersebut, kita melihat bahwa PyTorch mengklasifikasikan
gambar tersebut merupakan angka 5.

Apabila kita ingin mengecek gambar yang lain, kita bisa mencoba melihat index lain sesuai
yang kita inginkan, namun untuk contoh berikut ini, kita akan melanjutkan penulisan sintaks dengan
angka 5 ini. Setelah kita memahami bagaimana bentuk dari data MNIST ini, kita akan mencoba untuk
mengacak data tersebut dengan menggunakan DataLoader. DataLoader ini berfungsi untuk
memasukkan gambar MNIST tersebut menjadi beberapa batch yang akan digunakan untuk proses
pelatihan. Kita akan mengacak data tersebut agar kita benar - benar memiliki data acak untuk melatih
model autoencoder yang nanti akan kita buat.

108
 Kita dapat mengecek data yang ada pada batch pertama, untuk mendapat gambaran seperti apa
data yang akan digunakan nantinya untuk melatih autoencoder kita. Untuk itu, kita dapat menuliskan
sintaks berikut ini.

Kita menggunakan fungsi make_grid dan fungsi dari NumPy yaitu set_printoptions yang
digunakan untuk membuat format tampilan yang kita gunakan nanti untuk menampilkan batch. Untuk
mendapatkan batch pertama kedalam sebuah variabel, kita bisa memanfaatkan fungsi iterasi, lalu kita
akan memanggil fungsi break untuk keluar dari proses iterasi. Ini digunakan hanya untuk
memasukkan data tersebut pada variabel images dan labels. Setelah ini, kita akan mencoba untuk
menampilkan data batch tersebut.

109
 Dengan menggunakan fungsi tersebut, kita akan mengeluarkan 12 data dari batch pertama.
Kita ingat bahwa pada fungsi train_loader yang kita tuliskan sebelumnya, kita memiliki ukuran
batch sebesar 100, yang berarti tiap batch akan memiliki 100 data. Dengan jumlah data MNIST
sebanyak 60.000 data, maka akan terbentuk 600 batch yang nantinya akan kita proses untuk melatih
model kita. Selanjutnya, kita akan mencoba untuk merancang model yang akan kita gunakan untuk
membuat autoencoder ini.

Membuat model Autoencoder

Seperti yang telah dijelaskan pada bagian teori, model Autoencoder ini akan terdiri dari
sebuah encoder yang berperan untuk menerima bagian input, lalu kita akan membuat sebuah decoder
yang akan mengeluarkan output. Dengan ukuran layer yang diperkecil (kompresi) pada bagian
encoder, kita mengharapkan bahwa decoder kita masih dapat menampilkan kembali data tersebut
dengan baik, sehingga kita masih dapat mencerna informasi didalamnya.
Untuk merancang model ini, kita akan menggunakan model Linear dengan ukuran layer
adalah 784 >> 128 >> 84 >> 128 >> 784. Angka 784 ini merupakan jumlah layer input yang
merupakan ukuran dari gambar MNIST kita (28 x 28).

110
 Kita menggunakan activation function ReLU antar layer, dan menggunakan sigmoid function
sebagai output, karena nilai output yang kita harapkan akan berada pada rentang nilai antara 0 sampai
1 (perhatikan isi variabel train_data yang sebelumnya kita tampilkan). Perhatikan bahwa
self.encoder1 merupakan input yang menerima data gambar, sedangkan self.decoder3 merupakan
output yang akan melakukan prediksi terhadap gambar.
Kita akan memasukan model tersebut dalam variabel model. Kita juga akan membuat loss
function dan menggunakan MSE sebagai loss function. Tidak lupa juga kita akan membuat sebuah
optimizer dengan menggunakan Adam Optimizer, dengan nilai learning rate yang kita gunakan
adalah 0,001.

Dengan jumlah layer yang kompleks, maka kita akan memiliki jumlah parameter yang
banyak. Hal ini dapat berdampak pada waktu pelatihan model yang dibutuhkan nantinya. Dengan
nilai learning rate yang kecil, kita mungkin akan mendapatkan nilai yang lebih akurat, namun
mungkin akan membutuhkan waktu yang lebih lama. Kita bisa mengecek jumlah parameter yang
digunakan dalam model tersebut.

111
Melatih Model

Setelah membuat seluruh parameter yang akan digunakan untuk melatih model, kita akan
melatih model Autoencoder kita. Sebelum itu, kita perlu memperhatikan untuk mengubah ukuran
dari gambar kita. Ketika kita membuat model encoder sebelumnya, kita menuliskan bahwa ukuran
dari input kita merupakan 784, sedangkan apabila kita cek ukuran dari tensor kita, ukurannya adalah
[1,28,28].

Untuk itu, kita akan mengubah ukuran ini dengan menggunakan fungsi reshape. Dengan
menuliskan nilai -1, maka kita akan mengubah bentuknya menjadi sebuah dimensi, sehingga nilai dari
seluruh pixel tersebut akan dikalikan sehingga menjadi 1 dimensi.

Setelah memahami konsep ini, kita akan melakukan pelatihan terhadap model Autoencoder
kita.

112
 Kita akan melatih model kita untuk 10 episode pelatihan. Pada tiap pelatihan, kita akan
mengubah bentuk gambar input sesuai dengan yang ukuran yang dapat diterima encoder dengan
menggunakan reshape. Setelah itu, kita akan memasukkan gambar tersebut dalam model kita, lalu
kita akan menghitung loss nya dengan menggunakan criterion yang kita buat sebelumnya. Kita juga
akan memanggil fungsi optimizer yang kita buat sebelumnya. Tiap 200 batch, kita akan mencatat
hasilnya.

Perhatikan bahwa nilai loss cenderung mengecil pada tiap episode dan batch. Untuk melihat
hasilnya lebih jelas, kita akan coba memvisualisasikan hasil loss tersebut dengan matplotlib.

113
 Perhatikan bahwa untuk tiap episode, nilai loss kita cenderung menurun. Sampai pada epoch
6.000 (600 batch dan 10 episode), kita mendapatkan nilai loss yang cenderung mendekati 0. Hal ini
menunjukkan bahwa performa model kita cukup baik untuk melakukan prediksi. Kita akan mencoba
untuk merekonstruksi ulang gambar yang telah kita perkecil pixelnya dengan encoder dan
mengembalikannya dengan decoder.

114
 Kita akan mencoba menampilkan perbandingan gambar asli dengan gambar hasil rekonstruksi
ulang bersamaan. Kita akan memasukkan seluruh gambar tersebut dalam sebuah list terlebih dahulu.
Kita akan mencoba untuk melihat salah satu gambar pada index ke nol. Perhatikan hasilnya berikut
ini.

Gambar sebelah kiri merupakan gambar asli yang kita miliki dari dataset MNIST, sedangkan
gambar yang sebelah kanan merupakan gambar hasil rekonstruksi ulang dengan menggunakan
autoencoder. Sesuai dengan prinsip pada autoencoder yang memiliki kemiripan dengan
unsupervised learning, komputer tidak akan mengetahui apakah gambar hasil rekonstruksi tersebut
memiliki label yang tepat, namun kita sebagai manusia dapat melihat bahwa Autoencoder berhasil
membuat gambar yang mirip dengan gambar aslinya, dan kita masih dapat memahami bahwa gambar
rekonstruksi tersebut adalah angka 4. Hal ini membuktikan bahwa autoencoder kita berhasil untuk
mengembalikan informasi yang telah dilakukan kompresi sebelumnya dan memberikan hasil yang
akurat.
Kita telah berhasil untuk menerapkan penggunaan PyTorch untuk membuat sebuah
autoencoder. Pada bagian berikutnya, kita akan mencoba untuk menerapkan hal yang sama dengan
menggunakan dataset MNIST dan library Tensorflow dan Keras.

115
Studi Kasus - Autoencoder untuk Data MNIST (Tensorflow dan Keras)

Pada bagian ini, kita akan membuat sebuah autoencoder dengan menggunakan library
Tensorflow dan Keras. Pada bagian sebelumnya, kita telah melihat bagaimana cara kerja penggunaan
autoencoder pada data MNIST, dimana kita berhasil mengekstrak gambar asli, lalu autoencoder
akan melakukan rekonstruksi ulang terhadap gambar tersebut. Langkah - langkah yang akan kita
gunakan untuk membuat model autoencoder dengan Tensorflow dan Keras sama seperti yang kita
gunakan ketika membuat model autoencoder dengan PyTorch.

Menyiapkan data
Kita akan memanggil dahulu library yang akan kita gunakan untuk membuat autoencoder
dengan Tensorflow dan Keras ini.

Sama seperti PyTorch, Tensorflow juga memiliki sebuah library yang menampung datasets,
dimana salah satu dataset tersebut merupakan dataset MNIST. Kita dapat memanggil dataset ini
dengan mengetikkan from tensorflow.keras.datasets import mnist. Berbeda dengan PyTorch, kita
tidak perlu mendownload data tersebut dalam Google Colab, kita bisa memanggil data tersebut
dengan menggunakan fungsi load(). Kita akan menyimpan keseluruhan data MNIST tersebut dalam
variabel X_train, y_train, X_test, dan y_test. Karena data gambar yang kita miliki masih memiliki
rentang 0 sampai 255, maka kita akan melakukan normalisasi dengan membagi seluruh nilai pixel
dengan 255, sehingga keseluruhan nilai pixel pada keseluruhan gambar MNIST akan berada pada
rentang 0 dan 1. Berbeda juga dengan PyTorch, disini kita menggunakan tipe data NumPy.
Perhatikan gambar berikut untuk melihat penulisan sintaks yang digunakan.

116
 Apabila kita perhatikan ukuran data X_train tersebut, jumlah data yang kita panggil dari
database MNIST dari Tensorflow memiliki ukuran jumlah data sebanyak 60.000, sama seperti jumlah
data yang kita gunakan pada PyTorch. kita juga melihat bahwa tipe data yang digunakan oleh
X_train adalah tipe data NumPy Array. Untuk melihat bentuk dari data yang kita panggil dari
library Tensorflow ini, kita bisa menggunakan imshow dari matplotlib untuk melihat bentuk
gambarnya. Perhatikan sintaks berikut ini.

117
 Dengan menggunakan plt.imshow(), kita dapat melihat salah satu bentuk data pada X_train.
Setelah kita mengenal bentuk data yang kita miliki, maka kita akan mencoba untuk membuat model
autoencoder dengan Tensorflow.

Membuat Model Autoencoder

Untuk membuat autoencoder, kita akan membuat bagian encoder dan decoder secara terpisah
terlebih dahulu. Ingat bahwa pada bagian teori, autoencoder terdiri dari sebuah encoder yang
merupakan bagian terdekat dengan input, dan akan memiliki jumlah layer yang mengecil pada bagian
hidden layernya, sedangkan sebuah decoder merupakan bagian yang terdekat dengan output, dan akan
memiliki jumlah layer output yang lebih besar dibandingkan dengan bagian hidden layernya. Kita
akan membuat skema layer seperti yang kita buat pada PyTorch, yaitu dengan jumlah input 784 >>
128 >> 84 >> 18 >> 84 >> 128 >> 784. Kita akan melihat terlebih dahulu bagaimana cara menulis
encodernya.

Model encoder dibuat dengan menggunakan model Sequential dari Tensorflow, dengan layer
awal merupakan bagian input yang memiliki ukuran input 28 x 28 sesuai jumlah pixel pada tiap
gambar. Kita akan menggunakan Flatten agar ukurannya berubah menjadi 1 dimensi. Sesuai dengan
skema, kita akan menambahkan layer berikutnya yang berjumlah 128 dengan activation function
ReLU, lalu menambahkan lagi jumlah layer sebanyak 84 dan 18 dengan masing - masing memiliki
activation function ReLU.
Kita telah selesai membuat model encoder. Setelah ini, kita akan membuat model decoder,
dimana bentuk penulisannya merupakan kebalikan dari model decoder.

118
 Pada model decoder, kita juga akan membuat model tersebut dengan menggunakan model
Sequential dari Tensorflow. Kita akan menambahkan layer pertama yang merupakan layer input
bagi decoder. Karena decoder ini secara konsep merupakan bagian lanjutan dari encoder, dimana
inputnya berasal dari hidden layer dari encoder, maka kita akan menuliskan input_shape sebesar 18,
dimana jumlah ini didapat dari jumlah layer terakhir pada encoder. Kita juga akan menambahkan
jumlah layer sebanyak 84, sama seperti urutan pada encoder dengan activation function ReLU. Kita
juga akan menambahkan lagi sebuah layer dengan jumlah 128 layer, dengan activation function
ReLU. Pada layer terakhir, kita akan menuliskan jumlah layer output yaitu 784, yang didapatkan dari
28x28 sesuai jumlah pixel pada gambar. Disini kita memberikan activation function sigmoid, karena
nilai pixel ini berada pada rentang 0 sampai 1 akibat normalisasi yang kita lakukan sebelumnya. Kita
akan menambahkan sebuah layer Reshape() terakhir untuk mengubah ukuran output dari 1x784
menjadi 28x28, untuk membuat NumPy tersebut kembali menjadi 2 dimensi dan membentuk sebuah
gambar.
Setelah bagian encoder dan decoder terbentuk, kita akan kembali membuat sebuah model
Sequential yang bernama autoencoder, untuk menggabungkan encoder dan decoder ini menjadi
satu. Tidak lupa juga, kita akan memberikan sebuah loss function dan juga optimizer. Kita akan
menggunakan MSE sebagai loss functionnya, lalu kita juga akan menggunakan Adam Optimizer
dengan nilai learning rate yang kita gunakan sama seperti yang kita gunakan pada PyTorch, yaitu
0,001.

Setelah seluruh komponen untuk pelatihan model terbentuk, kita akan membuat sintaks untuk
melatih model autoencoder tersebut. Perhatikan sintaks berikut ini.

119
Melakukan Pelatihan Model

Kita akan melatih model tersebut dalam 10 episode. Perhatikan disini kita melihat bahwa kita
menuliskan X_train dan X_test masing - masing 2 kali. Hal ini dikarenakan ketika kita memasukkan
data pada autoencoder, kita membutuhkan nilai X_train dan y_train, serta X_test dan y_test. Pada
kasus autoencoder, ingat bahwa autoencoder merupakan sebuah unsupervised learning, sehingga
disini kita seakan tidak memiliki sebuah label (walaupun pada data MNIST yang kita ambil dari
library Tensorflow awalnya memiliki nilai label y). Kita tidak akan menggunakan nilai label yang
kita ambil dari library Tensorflow sebelumnya, oleh karena itu, kita akan menggantikan posisi
y_train dengan X_train, lalu posisi y_test dengan X_test. Kita akan menggunakan test data sebagai
sebuah validasi yang digunakan untuk menghitung nilai loss nantinya pada proses pelatihan. Apabila
kita menjalankan sintaks tersebut, kita akan memulai proses pelatihan model autoencoder yang akan
berjalan selama 10 episode. Perhatikan hasil outputnya berikut ini.

Perhatikan nilai loss dan val_loss yang dihasilkan pada proses pelatihan. Kita melihat bahwa
nilai loss dan val_loss cenderung berkurang pada tiap episode pelatihan yang terjadi. Hal ini berarti
nilai parameter yang kita gunakan untuk membangun model autoencoder ini bisa dibilang cukup
baik, dan model kita memiliki tingkat akurasi yang tinggi untuk melakukan prediksi.

120
Proses Rekonstruksi
Pada bagian sebelumnya kita melihat bahwa performa model autoencoder cukup baik,
dengan nilai loss dan val_loss yang cenderung berkurang pada tiap episode pelatihan yang dilakukan.
Sekarang kita akan mencoba untuk melakukan sebuah prediksi menggunakan model autoencoder
yang kita buat. Kita hanya akan menggunakan 10 data pertama saja agar waktu prediksi yang
dibutuhkan tidak terlalu lama. Kita akan menyimpan hasil prediksi model tersebut dalam variabel
bernama prediction. Perhatikan sintaksnya berikut ini.

Pada variabel prediction ini, kita menyimpan hasil gambar yang terbentuk dari model
autoencoder. Artinya, gambar yang terbentuk ini merupakan gambar rekonstruksi dimana kita
memberikan input pada model autoencoder, lalu gambar tersebut akan melalui serangkaian layer
didalamnya yang diperkecil ukuran layernya, lalu akan dikembalikan jumlah layernya sesuai dengan
input yang diberikan. Kita akan mencoba untuk membandingkan gambar asli dengan gambar hasil
rekonstruksi tersebut. Perhatikan sintaks berikut ini.

Kita akan mencoba untuk melihat gambar pada index ke nol pada gambar asli dan juga gambar
hasil rekonstruksi. Dengan menggunakan library matplotlib, kita akan menampilkan gambar asli dari
X_test dengan gambar rekonstruksi dari variabel prediction secara bersebelahan. Perhatikan gambar
berikut ini.

121
 Perhatikan kedua gambar di atas. Gambar sebelah kiri merupakan gambar asli dari X_test,
sedangkan gambar sebelah kanan merupakan gambar hasil rekonstruksi dari autoencoder. Perhatikan
bahwa komputer tidak akan bisa menentukan apakah gambar hasil rekonstruksi tersebut memiliki arti
yang sama dengan gambar asli, karena kita ingat kita tidak memberikan label y ketika kita melakukan
pelatihan model autoencoder. Namun sebagai manusia, kita tentu bisa mengartikan gambar tersebut,
dimana pada gambar asli kita bisa melihat angka 7, sedangkan autoencoder berhasil membuat
gambar angka 7 yang mirip dengan gambar asli.
Sebagai kesimpulan, dengan menggunakan autoencoder, kita dapat dengan mudah
merekonstruksi ulang sebuah gambar, sehingga mungkin kita dapat melihat lebih jelas ataupun
mengekstrak informasi lebih detail mengenai informasi yang mungkin sebelumnya tidak terlalu jelas
terlihat pada gambar asli. Kita juga mengetahui bahwa sebuah autoencoder sendiri merupakan
gabungan dari 2 model, yaitu encoder dan decoder. Kita dapat memecah kedua model ini menjadi
bagian encoder dan decoder tersendiri, tergantung kebutuhan dan bagaimana kita menginginkan
output dari proyek yang akan kita buat. Kita juga perhatikan bahwa gambar yang dihasilkan oleh
autoencoder, baik dengan menggunakan PyTorch ataupun Tensorflow dan Keras memiliki
beberapa blur dan mungkin tidak terlihat dengan jelas. Kita akan lebih mempelajari bagian ini lebih
lanjut pada Bab Computer Vision, mengenai bagaimana caranya kita memperbaiki gambar dan
mengekstrak informasi didalamnya.

122
 Kesimpulan
Deep Learning merupakan metode pembelajaran yang diadaptasikan dengan menggunakan
jaringan syaraf tiruan, atau yang lebih kita kenal sebagai neural network. Metode ini didasari dari cara
kerja pemikiran manusia, dimana dalam otak manusia, kita memiliki sebuah neuron yang digunakan untuk
memproses sinyal masukan dari dendrit. Tujuan dari penggunaan Deep Learning ini adalah kita akan
membuat beberapa neuron yang disusun sangat banyak, sehingga menciptakan sebuah layer yang disebut
dengan neural network. Apabila kita memiliki banyak layer, maka layer tersebut dapat disebut juga sebagai
deep neural network.
Deep Learning ini digunakan untuk mengekstrak informasi input lebih dalam lagi, agar
menemukan fitur - fitur yang penting yang berperan dalam pembentukan output. Beberapa metode yang
ada pada Deep Learning ini seperti ANN dan RNN digunakan untuk mendukung pengerjaan dari metode
Machine Learning, yaitu Supervised Learning, dan juga metode Deep Learning yaitu Autoencoder
yang digunakan untuk mendukung pengerjaan dari metode Machine Learning, yaitu Unsupervised
Learning. Selain itu, ada banyak metode juga yang terdapat dalam Deep Learning yang dapat digunakan
untuk metode lainnya, seperti CNN yang digunakan untuk pengolahan gambar, GAN, dan juga beberapa
fitur ANN yang digunakan untuk mendukung pengerjaan Reinforcement Learning, yang sempat dibahas
juga pada materi Reinforcement Learning, dimana salah satunya digunakan dalam metode DQN (Deep
Q-Network).
Dengan kita mencari informasi yang lebih dalam, kita dapat mengekspektasi bahwa hasil output
yang dihasilkan dari Deep Learning ini akan lebih baik dibandingkan dengan menggunakan metode
Machine Learning lainnya. Namun, kita masih harus tetap menyesuaikan parameter yang akan digunakan
agar mendapatkan model dengan nilai output yang optimal dan akurasi yang tinggi.

123
 Exercise
Cobalah untuk menjawab pertanyaan berikut ini berdasarkan yang telah kamu pelajari
pada bab ini

1. Sebutkan dan jelaskan minimal 3 perbedaan dengan membuat model Deep

Learning dengan menggunakan PyTorch dan juga Tensorflow dan Keras!
2. Perhatikan permasalahan berikut ini! Sebuah bank ingin mengetahui sebuah
permasalahan yang terjadi, dimana banyak nasabah bank tersebut yang mulai
tidak aktif dan pelan - pelan meninggalkan aplikasi bank tersebut, dan beberapa
mulai menarik saldonya. Sebagai seorang Machine Learning Engineer, cobalah
buat sebuah model Deep Learning dengan menggunakan ANN untuk
mengetahui nasabah yang mana saja yang berpotensi untuk meninggalkan bank
tersebut. Untuk mempermudah bank tersebut dalam mengontrol nasabahnya,
maka kita hanya akan menggunakan data nasabah yang berada di France saja
untuk awal - awal.

124