Pada tutorial ini, kita akan belajar mengenai Linear Regression. Contoh kasus disini adalah mengenai hubungan antara jumlah jam belajar dengan nilai ujian. Data yang kita pakai bisa didownload disini. Kita tentu tahu bahwa semakin sering siswa belajar maka semakin bagus pula skornya, tetapi disini kita akan membuktikannya secara matematik. Linear regression merupakan teknik dalam machine learning yang sangat sederhana. Dalam hal ini kita akan menggunakan optimisasi paling populer disini yakni gradient descent. Ilustrasinya adalah sebagai berikut:
Sumber: //raw.githubusercontent.com/mattnedrich/GradientDescentExample/master/gradient_descent_example.gifAcuan kita disini adalah garis yang menunjukkan ‘best fit’ yang dengan ini bisa memandu kita dalam menentukan hubungan antara jumlah jam belajar dengan nilai ujian. Kita bisa mendapatkan garis ‘best fit’ ini dengan menggunakan teknik gradient descent. Persamaan garis optimal ‘best fit’ ini adalah:
Sumber: //www.khanacademy.org/math/algebra/two-var-linear-equations/slope-intercept-form/v/slope-intercept-formDimana x disini menandakan variable independent / predictor yakni jumlah jam belajar siswa, sedangkan y adalah variable dependent / outcome yakni nilai ujian siswa.
Mari kita langsung ke implementasi kode nya:
Pertama, kita baca datanya dari file csv dan disajikan dalam bentuk array points.
def run():
points = genfromtxt(“data.csv”, delimiter=”,”)
learning_rate = 0.0001
initial_b = 0 # initial y-intercept guess
initial_m = 0 # initial slope guess
num_iterations = 1000
print “Starting gradient descent at b = {0}, m = {1}, error = {2}”.format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points))
print “Running…”
[b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)
print “After {0} iterations b = {1}, m = {2}, error = {3}”.format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points))
Iterasi = 1000 karena data kita termasuk kecil, jika data lebih besar bisa kita pakai iterasi 10000 atau diatasnya.
Kemudian, kita panggil fungsi gradient_descent_runner untuk menghitung nilai gradient dalam setiap iterasi.
def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
b = starting_b
m = starting_m
for i in range(num_iterations):
b, m = step_gradient(b, m, array(points), learning_rate)
return [b, m]
pada setiap iterasi, kita hitung nilai gradient dalam fungsi step_gradient. Secara matematis, fungsi gradient yang dipakai adalah sebagai berikut:
Sumber: //spin.atomicobject.com/wp-content/uploads/linear_regression_gradient1.pngRumus tersebut diterjemahkan dalam fungsi step_gradient dalam kode kita sebagai berikut:
def step_gradient(b_current, m_current, points, learningRate):
b_gradient = 0
m_gradient = 0
N = float(len(points))
for i in range(0, len(points)):
x = points[i, 0]
y = points[i, 1]
b_gradient += -(2/N) * (y – ((m_current * x) + b_current))
m_gradient += -(2/N) * x * (y – ((m_current * x) + b_current))
new_b = b_current – (learningRate * b_gradient)
new_m = m_current – (learningRate * m_gradient)
return [new_b, new_m]
Disamping itu, kita juga bisa menghitung error rate / loss function dari awal iterasi hingga akhir, sehingga kita bisa tahu efektifitas dari garis gradient descent yang kita miliki.
Nilai error ini disajikan dalam fungsi compute_error_for_line_given_points.
def compute_error_for_line_given_points(b, m, points):
totalError = 0
for i in range(0, len(points)):
x = points[i, 0]
y = points[i, 1]
totalError += (y – (m * x + b)) ** 2
return totalError / float(len(points))
Setelah dijalankan, hasil fungsi optimal dari Linear Regresi dengan Gradient Descent ini adalah sebagai berikut:
Starting gradient descent at b = 0, m = 0, error = 5565.10783448
Running…
After 1000 iterations b = 0.0889365199374, m = 1.47774408519, error = 112.614810116
Demikian implementasi sederhana linear regression dengan gradient descent dari dasar menggunakan python. Untuk kode lengkapnya ada di bawah ini:
from numpy import *
def compute_error_for_line_given_points(b, m, points):
totalError = 0
for i in range(0, len(points)):
x = points[i, 0]
y = points[i, 1]
totalError += (y – (m * x + b)) ** 2
return totalError / float(len(points))
def step_gradient(b_current, m_current, points, learningRate):
b_gradient = 0
m_gradient = 0
N = float(len(points))
for i in range(0, len(points)):
x = points[i, 0]
y = points[i, 1]
b_gradient += -(2/N) * (y – ((m_current * x) + b_current))
m_gradient += -(2/N) * x * (y – ((m_current * x) + b_current))
new_b = b_current – (learningRate * b_gradient)
new_m = m_current – (learningRate * m_gradient)
return [new_b, new_m]
def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
b = starting_b
m = starting_m
for i in range(num_iterations):
b, m = step_gradient(b, m, array(points), learning_rate)
return [b, m]
def run():
points = genfromtxt(“data.csv”, delimiter=”,”)
learning_rate = 0.0001
initial_b = 0 # initial y-intercept guess
initial_m = 0 # initial slope guess
num_iterations = 1000
print “Starting gradient descent at b = {0}, m = {1}, error = {2}”.format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points))
print “Running…”
[b, m] = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)
print “After {0} iterations b = {1}, m = {2}, error = {3}”.format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points))
if __name__ == ‘__main__’:
run()
Disusun oleh: Aditya Yanuar Roshadi
Referensi:
//github.com/llSourcell/linear_regression_live