Tensorflow 2.0-Linear Regression bagian 3

By | January 28, 2021
352 Views

Pembahasan kita akan semakin menarik saja ketika kita sudah paham cara kerja tensor pada tensorflow, pada bab sebelumnya kita sudah banyak membahas tensor, gradient descent-python, gradient descent-tensorflow, linear regression-gradient descent-octave. Jadi ada 3 cara kita belajar gradient descent melalui python-numpy, octave, dan tensor. Nah saya akan lanjutkan lagi Linear Regression- Gradient Descent menggunakan tensorflow saja. Kita akan fokus pada cara penggunaan placeholder, bila sebelumnya hanya menggunakan tf.Variable.

Pengertian Linear Regression – Regresi Linear

Untuk pengertian linear regression, kalian baca saja ini. Saya akan membahas sekilas saja mengenai MSE dan konsep turunan dari perhitungan MSE yang melibatkan rumus dari persamaan regresi linear, belum belum paham kalian pelajari saja bab sebelumnya. . Saya akan jabarkan mengenai variabel \hat y yang merupakan rumus dari persamaan regresi linear

(1)   \begin{equation*}  \begin{split} \hat y_i & = mx_i+b \end{split} \end{equation*}

*kalau ditulisan ini dibuat rumus y = ax+b tapi intinya adalah sama! cuman beda penamaan variabel saja, maka untuk mencari nilai error / loss function nya berupa nilai MSE (mean square error) dengan persamaan sebagai berikut

(2)   \begin{equation*}  \begin{split} MSE & = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat y_i)^2 \end{split} \end{equation*}

dengan

  1. N adalah jumlah data
  2. y adalah nilai faktual atau nilai target
  3. \hat y adalah nilai aktual atau nilai prediksi

Persamaan (1) akan dimasukan kedalam persamaan (2) menjadi berikut

(3)   \begin{equation*}  \begin{split} MSE & = \frac{1}{N} \sum_{i=1}^{N} (y - (mx+b))^2 \end{split} \end{equation*}

Kemudian persamaan diatas ada 2 variabel penting yang perlu dicari yaitu m dan b sehingga saya perjelas sebagai berikut

(4)   \begin{equation*}  \begin{split} MSE(m,b) & = \frac{1}{N} \sum_{i=1}^{N} (y - (mx+b))^2 \end{split} \end{equation*}

Yuk kita cari turunan pada persamaan (4) diatas untuk m dan b

Misalkan saja Berdasarkan persamaan 3, saya akan persingkat saja dari persamaan

    \[ y-(mx+b) \]

menjadi fungsi w yaitu

    \[ w = y-(mx+b) \]

fungsi turunan dari m akan menjadi

(5)   \begin{equation*}  \begin{split} \frac{df}{dm} & = \frac{1}{N} \sum_{i=1}^{N} (y - (mx+b))^2 \\ & = \frac{1}{N} \sum_{i=1}^{N} -2x(y-(mx+b)) \\ & = \frac{1}{N} \sum_{i=1}^{N} -2x w \\ \end{split} \end{equation*}

fungsi turunan dari b akan menjadi

(6)   \begin{equation*}  \begin{split} \frac{df}{db} & = \frac{1}{N} \sum_{i=1}^{N} (y - (mx+b))^2 \\ & = \frac{1}{N} \sum_{i=1}^{N} -2(y-(mx+b)) \\ & = \frac{1}{N} \sum_{i=1}^{N} -2w \end{split} \end{equation*}

Update Nilai m dan b

Untuk melakukan update m dan b, kita butuh nilai \alpha atau disebut dengan learning rate

    \[ m = m-\alpha*m \]

    \[ b = b-\alpha*b \]

Nilai \alpha mempunyai kisaran nilai 0 < \alpha < 1. Kalian sudah paham ya cara mencari fungsi turunan/derivatif diatas, kalau belum paham, belajar lagi bab sebelumnya.

Maka dari uraian diatas, cukup ribet ya, harus mencari turunan dari sebuah loss function berupa MSE, apalagi didalam MSE melibatkan 2 variabel yang akan diturunkan yaitu variabel m dan b. Ini hanya contoh kecil saja, lha kalau multiple regresion! pasti akan ada banyak sekali variable yang diturunkan! Kalau menggunakan tensorflow cukup menggunakan kode berikut saja, dimana f disebut loss function/objectiv function yang akan dicari nilai minimalnya serta menggunakan gradient descent sebagai fungsi turunannya!

f = x_pl * w + b #rumus untuk prediksi

# objective = loss = cost
loss = tf.reduce_mean(tf.square(f - y)) # L2 loss


# Optimization = Training
optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(loss)

Dataset dan Tensor Placeholder

Sudah cukup ya kita jelasin mengenai gradient descent, saat nya butuh dataset sebagai bahan uji coba regresi linear yaitu menggunakan dataset yang ada disini berupa dataset suhu dan jumlah cacat. Oiya karena kita akan memasukan dataset pada tensorflow, maka dibutuhkan tf.placeholder. Yuk kita import dulu datasetnya dari excel

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

tf.compat.v1.disable_eager_execution()

data = pd.read_excel('data.xlsx')
x = data['suhu']
y = data['jumlah_cacat']

Ingat karena kita butuh placeholder maka dibutuhkan ukuran shape nya, saya berikan nama x_pl (kepanjangan dari x placeholder)

n_data = len(x)
#bikin placeholder
x_pl = tf.compat.v1.placeholder(tf.float32, [n_data,], name="x_pl")
y_pl = tf.compat.v1.placeholder(tf.float32, [n_data,], name="y_pl")

Initial Value dari variabel m dan b

Oiya, kita butuh nilai tebakan awal/initial value untuk m dan b, misalkan untuk m=1.0 dan b=-10.0

#nilai awal
m = tf.Variable(1.0, tf.float32) 
b = tf.Variable(-10., tf.float32)

Membuat Rumus Prediksi / Regresi Linear loss function

Selanjutnya kita akan buat fungsi prediksi / rumus persamaan regresi linear yaitu

f = x_pl * m + b #rumus untuk prediksi

loss function yaitu meminimalkan perbedaan y dengan \hat{y} menggunakan MSE

# objective = loss = cost
loss = tf.reduce_mean(tf.square(f - y)) # L2 loss

Penetapan learning rate dan Fungsi gradient descent

Bila sudah OK, kita tentukan \alpha misalkan \alpha=0.001, berikut panggil fungsi gradient descent nya

# Optimization = Training
optimizer = tf.compat.v1.train.GradientDescentOptimizer(learning_rate)
train_op = optimizer.minimize(loss)

Membuat Session serta iterasi maksimalnya

Kalau sebelumya kita buat session denga with sehingga secara otomatis akan close, nah kali ini kita akan buat session tensor secara konvesional saja jadi ntar setelah selesai, jangan lupa untuk close!

# start a session
sess = tf.compat.v1.Session()
sess.run(tf.compat.v1.global_variables_initializer())

saya kasih epoch 500 ribu dan setiap 10 ribu akan dicetak ke layar serta diberikan sess.close()

loss_list = list()
for epoch in range(500000):
    _, _loss, _m, _b = sess.run([train_op, loss, m, b], {x_pl:x, y_pl:y})
    if np.mod(epoch,10000)==0:
        print ("\r Epoch-{}, \t _loss {}, \t _m: {},\t _b: {}".format(epoch,_loss,_m,_b))
    loss_list.append(_loss)

print('m: ',_m) 
print('b: ',_b)     
sess.close()

hasil

Epoch-460000, _loss 1.299, _m: 1.399, _b: -24.299
Epoch-470000, _loss 1.299, _m: 1.399, _b: -24.299
Epoch-480000, _loss 1.299, _m: 1.399, _b: -24.299
Epoch-490000, _loss 1.299, _m: 1.399, _b: -24.299
m: 1.4481584
b: -24.341614

 

Berikut ketika hasil loss_list ditampilan dalam sebuah grafik Linear Regression- Gradient Descent

Kalian bisa melihat pada epoch ke 100 ribu sudah mulai turun dan konstant!

Berikut tampilan CPU Prosessor ketika menjalankan tensor yang terlihat ada beberapa kali naik turun, hal ini wajar saja karena memang tensor akan mengatur core processor. Kalau mau cepat kalian harus pakai NVIDIA yang support CUDA sehingga GPU yang akan  melakukan perhitungan.

 

Gimana menurut kalian Linear Regression- Gradient Descent? semakin menarik bukan?

Leave a Reply

Your email address will not be published.




Enter Captcha Here :