Tìm hiểu sâu về hồi quy tuyến tính (triển khai 3 chiều)

Hồi quy tuyến tính (linear regression) là nguồn gốc của Học máy đối với nhiều người mới bắt đầu. Mọi người bắt đầu học ML từ Hồi quy tuyến tính và sau đó tiếp tục thực hiện các dự án tuyệt vời. Nếu ai đó tuyên bố là không biết gì về sự tuyệt vời của Machine Learning, họ chắc chắn đang sống dưới một tảng đá.

Hãy bắt đầu với khái niệm cơ bản về Học máy và tham quan thế giới thống kê và Học máy. Hồi quy tuyến tính về cơ bản có nghĩa là điều chỉnh một đường cho một tập hợp các điểm đại diện cho các đối tượng địa lý.

Hồi quy tuyến tính không chỉ quan trọng đối với ML, nó cũng quan trọng đối với Thống kê. Phương pháp ước lượng bình phương tối thiểu được sử dụng trong thống kê để tính gần đúng nghiệm của hồi quy tuyến tính bằng cách giảm thiểu khoảng cách bình phương nhỏ nhất của các điểm từ đường hồi quy.

Hàm giả thiết biểu diễn phương trình của đường được lắp. Tại đây theta-0theta-1 biểu diễn các tham số của đường hồi quy. Trong phương trình đường thẳng ( y = mx + c ), m là một hệ số góc và c là giao điểm y của đường thẳng. Trong phương trình đã cho, theta-0 là giao điểm y và theta-1 là hệ số góc của đường hồi quy.

Lưu ý: Ở đây chúng ta đang xử lý một biến độc lập duy nhất ( x ).

Các phương trình để tính giá trị của theta-0theta-1 được cho dưới đây. Chúng tôi tính toán các giá trị bằng cách sử dụng các phương trình này; phương pháp này được gọi là phương pháp ước lượng bình phương nhỏ nhất (Least Square estimation method).

Ở đây, chúng tôi đang đại diện cho các đặc trưng (các biến độc lập) cho mỗi mẫu dưới dạng x-i và giá trị trung bình của chúng là x-bar. Đầu ra (các biến phụ thuộc) cho mỗi mẫu được biểu thị bằng y-i và giá trị trung bình của chúng là y-bar. Tổng số mẫu là n.

Sau khi áp dụng các phương trình trên, chúng ta có thể tìm ra đường phù hợp nhất cho các điểm phân tán. Mã Python cho điều này được trình bày bên dưới.

import numpy as np 
import matplotlib.pyplot as plt 

def estimate_coef(x, y): 
    n = np.size(x) 
    m_x, m_y = np.mean(x), np.mean(y) 

    SS_xy = np.sum(y*x) - n*m_y*m_x 
    SS_xx = np.sum(x*x) - n*m_x*m_x 

    theta_1 = SS_xy / SS_xx 
    theta_0 = m_y - theta_1*m_x 

    return(theta_0, theta_1) 

def plot_regression_line(x, y, theta): 

    plt.scatter(x, y, color = "b",marker = "o", s = 30) 
    y_pred = theta[0] + theta[1]*x 

    plt.plot(x, y_pred, color = "r") 

    plt.xlabel('x') 
    plt.ylabel('y') 
    plt.show() 


x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
y = np.array([11 ,13, 12, 15, 17, 18, 18, 19, 20, 22]) 

theta = estimate_coef(x, y) 
print("Estimated coefficients:\ntheta_0 = {} \ntheta_1 = {}".format(theta[0], theta[1])) 

plot_regression_line(x, y, theta) 

print(round(theta[0]+ theta[1]*11,4))

Vấn đề tương tự của hồi quy tuyến tính có thể được giải quyết trong Học máy theo ba cách khác nhau.

Các phương pháp là:

  • Sử dụng chức năng LinearRegression tích hợp sẵn của thư viện scikit-learning.
  • Sử dụng Phương pháp Gradient Descent.
  • Sử dụng phương pháp nghịch đảo Moore-Penrose.

Hồi quy tuyến tính sử dụng scikit learning

Phương pháp đơn giản nhất là sử dụng một hàm thư viện có sẵn (mã cho điều này được đưa ra bên dưới). Tập dữ liệu được sử dụng giống với tập dữ liệu được sử dụng ở trên. Sau khi lắp dòng, chúng ta cần tìm giá trị của y cho x = 11. Chúng ta sẽ sử dụng cùng một tập dữ liệu và các giá trị đầu vào cho tất cả các phương pháp khác nhau được sử dụng.

Các LinearRegression() chức năng có các thông số đầu vào dưới dạng ma trận thưa thớt hình dạng (N_SAMPLES, n_features) và (N_SAMPLES, n_targets).

import numpy as np;
from sklearn.linear_model import LinearRegression;


x = np.array([[0], [1],[2], [3], [4], [5], [6], [7], [8], [9]]) 
y = np.array([[11], [13], [12], [15], [17], [18], [18], [19], [20], [22]]) 


LR=LinearRegression()
LR.fit(x,y)
b=LR.predict(np.array([[11]]))

print(round(b[0][0],4))

Hồi quy tuyến tính sử dụng gradient descent

Gradient Descent là một trong những phương pháp phổ biến nhất được sử dụng để tối ưu hóa các hàm lồi khác nhau trong Học máy. Vì chúng ta biết rằng hàm chi phí tương tự như hàm chi phí (với sự khác biệt của hệ số là 1/2) được cho trong Phương pháp bình phương tối thiểu, chúng ta sẽ sử dụng Gradient Descent để giải quyết vấn đề. Chúng ta phải tối thiểu hóa hàm chi phí để tìm giá trị của Theta trong đường hồi quy.

Phương pháp giảm độ dốc có thể được biểu diễn như sau:

Vì chúng tôi không thể cập nhật các giá trị của theta-0theta-1 đồng thời, chúng tôi sử dụng các biến tạm thời:

import numpy as np;
from matplotlib import pyplot as plt;

# Function for cost function
def cost(z,theta,y):
    m,n=z.shape;
    htheta = z.dot(theta.transpose())
    cost = ((htheta - y)**2).sum()/(2.0 * m);
    return cost;

def gradient_descent(z,theta,alpha,y,itr):
    cost_arr=[]
    m,n=z.shape;
    count=0;
    htheta = z.dot(theta.transpose())
    while count<itr:
        htheta = z.dot(theta.transpose())
        a=(alpha/m)
        # Using temporary variables for simultaneous updation of variables

        temp0=theta[0,0]-a*(htheta-y).sum();

        temp1=theta[0,1]-a*((htheta-y)*(z[::,1:])).sum();
        theta[0,0]=temp0;
        theta[0,1]=temp1;
        cost_arr.append(float(cost(z,theta,y)));

        count+=1;

    cost_log = np.array(cost_arr);

    plt.plot(np.linspace(0, itr, itr, endpoint=True), cost_log)
    plt.xlabel("No. of iterations")
    plt.ylabel("Error Function value")
    plt.show()

    return theta;

x = np.array([[0], [1],[2], [3], [4], [5], [6], [7], [8], [9]]) 
y = np.array([[11], [13], [12], [15], [17], [18], [18], [19], [20], [22]]) 

m,n=x.shape;

z=np.ones((m,n+1),dtype=int);

z[::,1:]=x;


theta=np.array([[21,2]],dtype=float)

theta_minimised=gradient_descent(z,theta,0.01,y,10000)
new_x=np.array([1,11])


predicted_y=new_x.dot(theta_minimised.transpose())

print(round(predicted_y[0],4));

Hồi quy tuyến tính sử dụng phương pháp nghịch đảo giả

Phương trình tìm theta trong trường hợp nghịch đảo Moore-Penrose là:

θ = (X ′ X) −1 X ′ y

Nó được thực hiện trong đoạn mã dưới đây.

import numpy as np;

# Input Matrix
x= np.array([[0], [1],[2], [3], [4], [5], [6], [7], [8], [9]]) 

# Output Matrix
y= np.array([[11], [13], [12], [15], [17], [18], [18], [19], [20], [22]]) 
m,n=x.shape;

# Adding extra ones for the theta-0 or bias term
z=np.ones((m,n+1),dtype=int);

z[:,1:]=x; # z is Input matrix with added 1s

mat=np.matmul(z.transpose(),z); # product of z and z transpose
matinv=np.linalg.inv(mat) #inverse of above product
val=np.matmul(matinv,z.transpose()) # Product of inverse and z transpose
theta=np.matmul(val,y) # Value of theta by multiplying value calculated above to y

new_x=np.array([1,11]);
predicted_y=new_x.dot(theta);

print(round(predicted_y[0],4));

Luyện tập

Bây giờ chúng ta đã học về hồi quy tuyến tính, hãy áp dụng nó cho một Tập dữ liệu thực. Tập dữ liệu chúng tôi sẽ sử dụng là tập dữ liệu Boston.

Nó có 506 mẫu, 13 tính năng và một cột làm cột đầu ra. Cột 14 là đầu ra. Dưới đây là mã mẫu cho Bộ dữ liệu Boston.

import numpy as np;
from sklearn.linear_model import LinearRegression;

from sklearn.datasets import load_boston
X, y = load_boston(return_X_y=True)

print(X.shape)
# We can see that there are 13 features
LR=LinearRegression()
LR.fit(X,y)

# finding the price for given input
b=LR.predict([[0.00632,18.0,2.31,0.0,0.538,6.57,65.5,4.09,1,296,15.5,396.9,4.98]])

print(b)