Yuk Belajar membuat desain neural network dengan Tensorflow
Membuat desain arsitektur machine learning menggunakan python sangatlah mudah, kalian bisa saja membuat kode nya secara sendiri, ataupun menggunakan library yang ada ada bahkan membuat turunan class / inheritance dari sebuah class library tensorflow! Maksudnya adalah kalian bisa saja menggunakan library tensorflow dari sebuah class – class yang ada untuk digunakan kembali sebagai acuan kita dalam membuat machine learning seperti backpropagation! Penasaran bukan?
Tulisan sebelumnya
Contents
Pada tulisan sebelumnya, disitu kita hanya menggunakan library sklearn yaitu terbatas memanggil function saja, dengan menggunakan dataset yang sama, kita akan menggunakan library tensorflow dan keras sebagai backend engine nya.
Yuk mulai saja kita samakan saja version tensorflow dan keras yang digunakan
import tensorflow as tf import keras as kr tf.__version__ kr.__version__
menampilkan versi tensorflow dan keras sebagai berikut
tf.__version__ Out[2]: '2.2.0-rc3' kr.__version__ Out[3]: '2.3.1'
Silahkan bagi sobat semua untuk mengecek versinya masing-masing
Persiapan dataset pada Tensforflow
Kita perlu menyiapkan dataset yang digunakan pada tensorflow yang mengharuskan target berupa one hot encoding. Pada dasarnya ada 2 teknik yang sering digunakan untuk membuat target dalam machine learning yaitu
- Integer Encoding
- One-Hot Encoding
Integer Encoding
Setiap nilai kategori unik diberi nilai integer. Misalnya,
- “red” adalah 1,
- “yellow” adalah 2,
- dan “green” adalah 3.
Ini disebut pengkodean label atau pengkodean integer dan mudah dibalik. Untuk beberapa variabel, ini mungkin cukup. Nilai integer memiliki hubungan teratur yang alami antara satu sama lain dan algoritma machine learning mungkin dapat memahami dan memanfaatkan hubungan ini.
One Hot Encoding
Untuk variabel kategori di mana tidak ada hubungan ordinal seperti itu, pengkodean integer tidak cukup. Faktanya, menggunakan pengkodean ini dan mengizinkan model untuk mengasumsikan urutan alami antar kategori dapat mengakibatkan kinerja yang buruk atau hasil yang tidak diharapkan (prediksi di tengah jalan antar kategori).
Dalam hal ini, pengkodean one-hot dapat diterapkan ke representasi integer. Di sinilah variabel yang dikodekan bilangan bulat dihapus dan variabel biner baru ditambahkan untuk setiap nilai bilangan bulat unik. Contohnya yaitu
kalian bisa lihat ilustrasi berikut bila ada 10 kelas target
sehingga dataset logika XOR yang kita gunakan semula
import numpy as np x = np.array([[0,0],[0,1],[1,0],[1,1]]) y = np.array([0,1,1,0])
akan diubah untuk variabel y menjadi berikut one hot encoding
import numpy as np
x = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([[1,0],
[0,1],
[0,1],
[1,0]])
atau kelasnya sudah banyak, kita bisa menggunakan to_categorical()
import numpy as np x = np.array([[0,0],[0,1],[1,0],[1,1]]) num_category = 2 y = np.array([0,1,1,0]) y = kr.utils.to_categorical(y, num_category)
maka y akan berubah menjadi berikut
array([[1., 0.],
[0., 1.],
[0., 1.],
[1., 0.]], dtype=float32)
Membuat Model Arsitektur Jaringan
Yup tahap selanjutnya membuat arsitekur jaringan, berapa banyak layer dan jumlah node yang akan kita gunakan, pada sebelumnya menggunakan 2 layer hidden masing-masing yaitu masing-masing terdiri dari 3 dan 4 node. Oiya kalian sudah paham kan OOP di Python yaitu kita bisa inheritance class Model pada TensorFlow!
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
class Net(Model):
def __init__(self):
super(Net, self).__init__()
self.d1 = Dense(3, activation='relu') #layer hidden 1
self.d2 = Dense(4, activation='relu') #layer hidden 2
self.d3 = Dense(2, activation='softmax') # layer output
def call(self, x):
x = self.d1(x)
x = self.d2(x)
return self.d3(x)
model = Net()
Kita membuat class bernama Net yang merupakan sebuah arsitektur JST dengan
- hidden 1 punya 3 node,
- hidden 2 punya 4 node.
Oiya untuk d3 (layer terakhir) harus dijelaskan secara eksplisit, sesuai dengan dataset target kita menggunakan 2 (num_category)
Masing-masing penjelasannya sebagai berikut
Bagian __init__
Atau disebut method super (OOP di JAVA) atau constructor yaitu untuk mendefinisikan layer apa saja yang akan digunakan. Pada kasus ini kita hanya akan menggunakan layer Dense dari Keras (Fully-Connected Layer). Fungsi Dense di sini mewakili sebuah layer. Variabel self.d1 mewakili hidden layer pertama yang berisi 3 neuron, dan variabel self.d2 mewakili layer output. Tensorflow memempermudah kita untuk membangun arsitektur tanpa perlu menspesifikasikan ukuran input. Pada kode di atas, tampak juga fungsi aktivasi yang digunakan pada masing-masing layer, yakni ReLU dan Softmax.
Bagian call – forward – perambatan maju
Method ini sama fungsinya sebagai forward() pada algoritma backpropagation atau sering disebut perhitungan maju bagaimana proses forward propagation terjadi terhadap input data x.
Optimasi Jaringan – backward() – perambatan mundur
Lalu dimanakan letak perhitungan mundur – backwardnya? Nah pada tensorflow dikenal dengan algoritma optimasi dan loss function. Algoritma optimasi adalah algoritma yang digunakan untuk memperbaiki eror pada JST. Ada banyak algoritma di Tensorflow yang bisa digunakan. Kali ini, kita akan gunakan Stochastic Gradient Descent (SGD) dengan learning rate sebesar 0.01. Langsung saja kita panggil kodenya
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
Sedangkan untuk loss function yaitu algoritma untuk menghitung eror yang akan kita gunakan. Untuk kasus ini kita akan menggunakan metode Cross-Entropy.
criterion = tf.keras.losses.CategoricalCrossentropy()
Saatnya melakukan iterasi – looping
Tahap selanjutnya berupa looping / iterasi dengan jumlah epoch yang kita tentukan sendiri, untuk alur dalam iterasi yaitu
- Inputkan data ke model untuk mendapatkan output model
- Hitung eror antara output dengan label
- Hitung gradient eror dengan `tape.gradient()`
- Update bobot menggunakan algoritma optimasi
Yuk mari kita coba saja ke point 4 diatas kedalam sebuah epoch maksimal sebesar 10 kali saja
for epoch in range(10):
with tf.GradientTape() as tape:
out = model(x)
loss = criterion(y, out)
print("%d / 10 -- loss = %.4f" % (epoch, loss.numpy()))
gradients = tape.gradient(loss, modelkita.trainable_variables)
optimizer.apply_gradients(zip(gradients, modelkita.trainable_variables))
kalian bisa melihat loss nya semakin turun
0 / 10 -- loss = 0.7683 1 / 10 -- loss = 0.7664 2 / 10 -- loss = 0.7646 3 / 10 -- loss = 0.7628 4 / 10 -- loss = 0.7611 5 / 10 -- loss = 0.7594 6 / 10 -- loss = 0.7578 7 / 10 -- loss = 0.7562 8 / 10 -- loss = 0.7546 9 / 10 -- loss = 0.7531
Kita coba saja sampai 100 ribu kali, tapi biar nggak bosen, output kita modifikasi hanya setiap 1000 iterasi akan ditampilkan saja, maka kode nya kita tambah np.mod(epoch,1000)
for epoch in range(100000):
with tf.GradientTape() as tape:
out = model(x)
loss = criterion(y, out)
if np.mod(epoch,1000)==0:
print("%d / 10ribu x -- loss = %.4f" % (epoch, loss.numpy()))
gradients = tape.gradient(loss, modelkita.trainable_variables)
optimizer.apply_gradients(zip(gradients, modelkita.trainable_variables))
berikut hasil di akhir-akhir epoch
86000 / 10ribu x -- loss = 0.0004 87000 / 10ribu x -- loss = 0.0004 88000 / 10ribu x -- loss = 0.0004 89000 / 10ribu x -- loss = 0.0004 90000 / 10ribu x -- loss = 0.0004 91000 / 10ribu x -- loss = 0.0004 92000 / 10ribu x -- loss = 0.0004 93000 / 10ribu x -- loss = 0.0004 94000 / 10ribu x -- loss = 0.0004 95000 / 10ribu x -- loss = 0.0004 96000 / 10ribu x -- loss = 0.0004 97000 / 10ribu x -- loss = 0.0004 98000 / 10ribu x -- loss = 0.0004 99000 / 10ribu x -- loss = 0.0004
semakin mengecil loss nya! sesuai dengan naiknya iterasi yang dilakukan
Play jaringan
Saatnya kita menggunakan model pelatihan diatas, langsung saja panggil predict()
model.predict(x)
Out[24]:
array([[9.9935466e-01, 6.4532907e-04],
[6.9286551e-05, 9.9993074e-01],
[6.7575354e-05, 9.9993241e-01],
[9.9935466e-01, 6.4532907e-04]], dtype=float32)
kita buat round saja, biar terlihat lebih jelas
np.round(model.predict(x))
Out[26]:
array([[1., 0.],
[0., 1.],
[0., 1.],
[1., 0.]], dtype=float32)
Wus! sudah sama dengan target kelas yang kita harapkan! cukup dengan 100 ribu epoch saja!
Simpan Model Jaringan
Lantas bagaimana setelah melakukan pelatihan yang cukup lama! tentu kalian bisa simpan hasil model diatas dalam bentuk JSON atau HDF5, baca saja deh disini cara simpan modelnya
Masih belum paham?
Kalau sobat belum paham, bisa belajar dasar-dasar python dan cara install disini ataupun berikirim surel kesini juga boleh.
