Linear Regression

Linear Regression

แสดงความสัมพันธ์ระหว่างตัแปรด้วย linear function

$h_{\theta }(x)={\theta }_0+{\theta }_1{x}_1+{\theta }_2{x}_2+{\theta }_3{x}_3...+{\theta }_k{x}_k$

เรียก $\theta$ ว่าเป็น parameter หรือ weight ที่ใช้ map ระหว่าง X และ Y
ในรูปแบบการเขียนแบบทั่วไป จะทำการเพิ่ม $x_0=1$ เรียกว่า "intercept term" เข้ามา

$h_{\theta }(x)={\theta }_0{x}_0+{\theta }_1{x}_1+{\theta }_2{x}_2+{\theta }_3{x}_3+...+{\theta }_k{x}_k$

$h_{\theta }(x)=\sum _{i=1}^n{\theta }_i{x}_i={\theta }^T\cdot X$

โดยที่สมการล่าสุดจะมอง $\theta ,X$ เป็น Vector และ n คือจำนวนของ input variable ที่ไม่นับ $x_0$

หลังจากกำหนด hypothesis function แล้ว ต่อไปคือขั้นการ train สมการด้วย data set ที่ได้จากการสังเกตุ เป้าหมายของการ train คือเพื่อให้ได้ชุดของ $\theta$ ที่นำมาใช้หาของ $h(x)$ ที่ใกล้เคียงกับค่า Response variable (y) ที่ได้จากการสังเกตุมากที่สุด เพื่อให้สามารถตรวจสอบได้ว่าค่าของ $h(x)$ ใกล้เคียงกับ y แค่ไหน เราจึงการกำหนด cost function  ขึ้นมา


Cost function

คือฟังก์ชั่นที่แสดงให้เราเห็นว่าค่าประมาณการมีความใกล้เคียงกับค่าสังเกตุเพียงใด หรือกล่าวอีกนัยว่าสมการ Regression ที่หาได้นั้นมีประสิทธิมากน้อยเพียงใด นิยามโดย

$J(\theta )=\frac{1}{2}\sum _{i=1}^N(h_{\theta }(x^{(i)})-y^{(i)}{)}^2$ หรือ

$J(\theta )=\frac{1}{2}\sum _{i=1}^N({\theta }^T{x}^{(i)}-y^{(i)}{)}^2$

ตัวแบบที่ดีควรมีค่าของ Cost function น้อยที่สุด นั้นคือเราต้องหาชุด $\theta$ ที่ทำให้ const function มีค่าน้อยที่สุด และ algorithm ที่นิยมใช้กันคือการใช้ Gradient descent

Gradient descent เปรียบได้กับการเดินลงเขาเพื่อไปหาจุดที่ต่ำที่สุด ด้วยการก้าวเล็กๆทีละก้าว

${▽}_{\theta }J(\theta )=\left[\begin{array}{c}\frac{\partial J(\theta )}{\partial \theta 1}\\ \frac{\partial J(\theta )}{\partial \theta 2}\\ \frac{\partial J(\theta )}{\partial \theta 3}\\ .\\ .\\ .\\ \frac{\partial J(\theta )}{\partial {\theta }_n}\end{array}\right]$

 เริ่มที่กำหนดค่าของ $\theta$ ขึ้นมาแบบสุ่มก่อน แทนค่าเข้าไปใน hypothesis function เพื่อดูค่า cost function ทำเช่นนี้ไปเรื่อย ๆ จนพบว่า ไม่สามารถทำให้ค่า cost function ต่ำไปกว่านี้ได้อีก
ดังนั้น Gradient จึงเป็นการใช้หลักการของ Derivative function ระหว่าง $J(\theta )$ กับ $\theta$ และการวนรอบเพื่อหาค่าที่เหมาะสม

${\theta }_j\equiv {\theta }_j-\alpha \frac{\partial J(\theta )}{\partial \theta }⇢(1)$

โดยกำหนดให้ $\alpha$  คือ Learning rate เปรียบได้กับขนาดของก้าว ค่านี้ควรมีค่าไม่มากเกินไปหรือน้อยเกินไป  (มากเกินไปอาจทำให้ก้าวข้ามจุดที่ต่ำที่สุดได้ เล็กเกินไปจะใช้เวลาประมวลผลนาน)

$\frac{\partial J(\theta )}{\partial {\theta }_j}=\frac{\partial \frac{1}{2}(h_{\theta }(x)-y{)}^2}{\partial {\theta }_j}$

$\frac{\partial J(\theta )}{\partial {\theta }_j}=\frac{1}{2}\times 2(h_{\theta }(x)-y)\frac{\partial (h_{\theta }(x)-y)}{\partial {\theta }_j}$

$\frac{\partial J(\theta )}{\partial {\theta }_j}=(h_{\theta }(x)-y)\frac{\partial (\sum _{i=0}^n{\theta }_i{x}_i-y)}{\partial {\theta }_j}$

$\frac{\partial J(\theta )}{\partial {\theta }_j}=(h_{\theta }(x)-y)x_j⇢(2)$

สมการที่ (2)  เป็นตัวแทนของ Gradient descent ของ Cost function  สำหรับ Linear regression เมื่อนำไปแทนค่าใน (1) จะได้

${\theta }_j\equiv {\theta }_j+\alpha (y^{(i)}-h_{\theta }(x^{(i)}))x_j^{(i)}⇢(3)$

เรียกสมการ (3) "update rule"  ที่ใช้หลักการ Least Mean Square (LMS) หรืออาจใช้ชื่อว่า "Widrow-Hoff learning rule"

อาจเรียก $y^{(i)}-h_{\theta }(x^{(i)})$ ว่าเป็น "Error" ก็ได้ เพราะมันคือความต่างระหว่างค่าที่ได้จากการสังเกตุกับค่าที่ได้จากการคำนวณจาก Regression

import numpy as np

class LinearReg():
    def __init__(self):
        self._iter = 1000
        self._lr = 0.1
        self._beta = None
        
    
    @property
    def iteration(self):
        return self._iter
    
    @property
    def learning_rate(self):
        return self._lr
    
    @property
    def beta(self):
        return self._beta    
    
    @iteration.setter
    def iteration(self,i):
        self._iter = i
        
    @learning_rate.setter
    def learning_rate(self,lr):
        self._lr = lr
    
    @beta.setter
    def beta(self,b):
        self._beta = b
    
    def fit(self,X,Y):
        X = np.insert(X,0,1,axis=1) # inject X0 into input vector with value 1
        
        _beta = np.zeros(X.shape[1]) # create beta vector 
        for i in range(self.iteration):
            for x,y in zip(X,Y):
                output = x.dot(_beta)
                _error = y - output 
                _beta = _beta + self.learning_rate * _error * x
        self.beta = _beta
    
    def predict(self,X):
        if self.beta is not None :
            X = np.insert(X,0,1,axis=1) 
            res= X.dot(self.beta)
            return res.reshape((X.shape[0],1))
            
        else :
            return None
        
        
    def r2(self,X,Y):
        '''
        r2 is defined by 1-u/v
        where 
        u = sum of (observ - predict)^2
        v = sum of (observ - mean of observ)^2
        '''
        u = np.sum(np.power(Y - self.predict(X) ,2))
        v = np.sum(np.power(Y - Y.mean(),2))
        return 1 - u/v

    
if __name__ == "__main__":
    X = np.array([[1],[2],[3],[4],[5]])
    Y = np.array([[1],[2],[3],[4],[5]])
    lr = LinearReg()
    lr.iteration = 1000
    lr.fit(X,Y)
    print(lr.beta)
    print(lr.predict(np.array([[7],[8],[100]])))
    print(lr.r2(X,Y))

      

เอกสารอ้างอิง
[1] https://en.wikipedia.org/wiki/Linear_least_squares#Derivation_of_the_normal_equations
[2] http://mathworld.wolfram.com/NormalEquation.html
[3] https://en.wikipedia.org/wiki/Ordinary_least_squares
[4] https://somchaisom.blogspot.com/2018/07/basic-linear-algebra-1.html