Yuk Belajar membuat desain neural network dengan Tensorflow

By | October 23, 2021
Print Friendly, PDF & Email
1,042 Views

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

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

  1. Integer Encoding
  2. One-Hot Encoding

Integer Encoding

Setiap nilai kategori unik diberi nilai integer. Misalnya,

  1. “red” adalah 1,
  2. “yellow” adalah 2,
  3. 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).

See also  Cara menggunakan loss function Negative log likelihood loss nn.NLLLoss

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

  1. hidden 1 punya 3 node,
  2. 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.

See also  Tensorflow 2.0-Linear Regression bagian 3

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

  1. Inputkan data ke model untuk mendapatkan output model
  2. Hitung eror antara output dengan label
  3. Hitung gradient eror dengan `tape.gradient()`
  4. 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

See also  Daftar Library Machine Learning

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.

Leave a Reply

Your email address will not be published.




Enter Captcha Here :