作者|Vagif Aliyev
編譯|VK
來源|Towards Data Science

線性迴歸可能是最常見的演算法之一，線性迴歸是機器學習實踐者必須知道的。這通常是初學者第一次接觸的機器學習演算法，瞭解它的操作方式對於更好地理解它至關重要。

所以，簡單地說，讓我們來分解一下真正的問題：什麼是線性迴歸？

線性迴歸定義

線性迴歸是一種有監督的學習演算法，旨在採用線性方法來建模因變數和自變數之間的關係。換句話說，它的目標是擬合一條最好地捕捉資料關係的線性趨勢線，並且，從這條線，它可以預測目標值可能是什麼。

太好了，我知道它的定義，但它是如何工作的呢？好問題！為了回答這個問題，讓我們逐步瞭解一下線性迴歸是如何運作的：

1. 擬合數據（如上圖所示）。

2. 計算點之間的距離（圖上的紅點是點，綠線是距離），然後求平方，然後求和（這些值是平方的，以確保負值不會產生錯誤的值並阻礙計算）。這是演算法的誤差，或者更好地稱為殘差

3. 儲存迭代的殘差

4. 基於一個優化演算法，使得該線稍微“移動”，以便該線可以更好地擬合數據。

5. 重複步驟2-5，直到達到理想的結果，或者剩餘誤差減小到零。

這種擬合直線的方法稱為最小二乘法。

線性迴歸背後的數學

如果已經理解的請隨意跳過這一部分

線性迴歸演算法如下：

可以簡化為：

以下演算法將基本完成以下操作：

1. 接受一個Y向量（你的資料標籤，（房價，股票價格，等等…）

這是你的目標向量，稍後將用於評估你的資料（稍後將詳細介紹）。

2. 矩陣X（資料的特徵）：

這是資料的特徵，即年齡、性別、性別、身高等。這是演算法將實際用於預測的資料。注意如何有一個特徵0。這稱為截距項，且始終等於1。

3. 取一個權重向量，並將其轉置：

這是演算法的神奇之處。所有的特徵向量都會乘以這些權重。這就是所謂的點積。實際上，你將嘗試為給定的資料集找到這些值的最佳組合。這就是所謂的優化。

4. 得到輸出向量：

這是從資料中輸出的預測向量。然後，你可以使用成本函式來評估模型的效能。

這基本上就是用數學表示的整個演算法。現在你應該對線性迴歸的功能有一個堅實的理解。但問題是，什麼是優化演算法？我們如何選擇最佳權重？我們如何評估績效？

成本函式

成本函式本質上是一個公式，用來衡量模型的損失或“成本”。如果你曾經參加過任何Kaggle比賽，你可能會遇到過一些。一些常見的方法包括：

• 均方誤差

• 均方根誤差

• 平均絕對誤差

這些函式對於模型訓練和開發是必不可少的，因為它們回答了“我的模型預測新例項的能力如何”這一基本問題？”. 請記住這一點，因為這與我們的下一個主題有關。

優化演算法

優化通常被定義為改進某事物，使其發揮其全部潛力的過程。這也適用於機器學習。在ML的世界裡，優化本質上是試圖為某個資料集找到最佳的引數組合。這基本上是機器學習的“學習”部分。

我將討論兩種最常見的演算法：梯度下降法和標準方程。

梯度下降

梯度下降是一種優化演算法，旨在尋找函式的最小值。它通過在梯度的負方向上迭代地採取步驟來實現這個目標。在我們的例子中，梯度下降將通過移動函式切線的斜率來不斷更新權重。

梯度下降的一個具體例子

為了更好地說明梯度下降，讓我們看一個簡單的例子。想象一個人在山頂上，他/她想爬到山底。他們可能會做的是環顧四周，看看應該朝哪個方向邁出一步，以便更快地下來。然後，他們可能會朝這個方向邁出一步，現在他們離目標更近了。然而，它們在下降時必須小心，因為它們可能會在某一點卡住，所以我們必須確保相應地選擇我們的步長。

同樣，梯度下降的目標是最小化函式。在我們的例子中，這是為了使我們的模型的成本最小化。它通過找到函式的切線並朝那個方向移動來實現這一點。演算法“步長”的大小是由已知的學習速率來定義的。這基本上控制著我們向下移動的距離。使用此引數，我們必須注意兩種情況：

1. 學習速率太大，演算法可能無法收斂（達到最小值）並在最小值附近反彈，但永遠不會達到該值

2. 學習率太小，演算法將花費太長時間才能達到最小值，也可能會“卡”在一個次優點上。

我們還有一個引數，它控制演算法迭代資料集的次數。

從視覺上看，該演算法將執行以下操作：

由於此演算法對機器學習非常重要，讓我們回顧一下它的作用：

1. 隨機初始化權重。這叫做隨機初始化

2. 然後，模型使用這些隨機權重進行預測

3. 模型的預測是通過成本函式來評估的

4. 然後模型執行梯度下降，找到函式的切線，然後在切線的斜率上邁出一步

5. 該過程將重複N次迭代，或者如果滿足某個條件。

梯度下降法的優缺點

優點：

1. 很可能將成本函式降低到全域性最小值（非常接近或=0）

2. 最有效的優化演算法之一

缺點：

1. 在大型資料集上可能比較慢，因為它使用整個資料集來計算函式切線的梯度

2. 容易陷入次優點（或區域性極小值）

3. 使用者必須手動選擇學習速率和迭代次數，這可能很耗時

既然已經介紹了梯度下降，現在我們來介紹標準方程。

標準方程（Normal Equation）

如果我們回到我們的例子中，而不是一步一步地往下走，我們將能夠立即到達底部。標準方程就是這樣。它利用線性代數來生成權重，可以在很短的時間內產生和梯度下降一樣好的結果。

標準方程的優缺點

優點

1. 無需選擇學習速率或迭代次數

2. 非常快

缺點

1. 不能很好地擴充套件到大型資料集

2. 傾向於產生好的權重，但不是最佳權重

特徵縮放

這是許多機器學習演算法的重要預處理步驟，尤其是那些使用距離度量和計算（如線性迴歸和梯度下降）的演算法。它本質上是縮放我們的特徵，使它們在相似的範圍內。把它想象成一座房子，一座房子的比例模型。兩者的形狀是一樣的（他們都是房子），但大小不同（5米！=500米）。我們這樣做的原因如下：

1. 它加快了演算法的速度

2. 有些演算法對尺度敏感。換言之，如果特徵具有不同的尺度，則有可能將更高的權重賦予具有更高量級的特徵。這將影響機器學習演算法的效能，顯然，我們不希望我們的演算法偏向於一個特徵。

為了演示這一點，假設我們有三個特徵，分別命名為A、B和C：

• 縮放前AB距離=>

• 縮放前BC距離=>

• 縮放後AB距離=>

• 縮放後BC的距離=>

我們可以清楚地看到，這些特徵比縮放之前更具可比性和無偏性。

從頭開始編寫線性迴歸

好吧，現在你一直在等待的時刻；實現！

注意：所有程式碼都可以從這個Github repo下載。但是，我建議你在執行此操作之前先遵循教程，因為這樣你將更好地理解你實際在編寫什麼程式碼：

https://github.com/Vagif12/ML-Algorithms-From-Scratch/blob/main/Linear Regression from Scratch.ipynb

首先，讓我們做一些基本的匯入：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston

是的，這就是所有需要匯入的了！我們使用的是numpy作為數學實現，matplotlib用於繪製圖形，以及scikitlearn的boston資料集。

# 載入和拆分資料
data = load_boston()
X,y = data['data'],data['target']

接下來，讓我們建立一個定製的train_test_split函式，將我們的資料拆分為一個訓練和測試集：

# 拆分訓練和測試集
def train_test_divide(X,y,test_size=0.3,random_state=42):
    np.random.seed(random_state)
    train_size = 1 - test_size
    arr_rand = np.random.rand(X.shape[0])
    split = arr_rand < np.percentile(arr_rand,(100*train_size))
    
    X_train = X[split]
    y_train = y[split]
    X_test =  X[~split]
    y_test = y[~split]
    
    return X_train, X_test, y_train, y_test
X_train,X_test,y_train,y_test = train_test_divide(X,y,test_size=0.3,random_state=42)

基本上，我們在進行

1. 得到測試集大小。

2. 設定一個隨機種子，以確保我們的結果和可重複性。

3. 根據測試集大小得到訓練集大小

4. 從我們的特徵中隨機抽取樣本

5. 將隨機選擇的例項拆分為訓練集和測試集

我們的成本函式

我們將實現MSE或均方誤差，一個用於迴歸任務的常見成本函式：

def mse(preds,y):
        m = len(y)
        return 1/(m) * np.sum(np.square((y - preds)))

• M指的是訓練例項的數量

• yi指的是我們標籤向量中的一個例項

• preds指的是我們的預測

為了編寫乾淨、可重複和高效的程式碼，並遵守軟體開發實踐，我們將建立一個線性迴歸類：

class LinReg:
    def __init__(self,X,y):
        self.X = X
        self.y = y
        self.m = len(y)
        self.bgd = False

• bgd是一個引數，它定義我們是否應該使用批量梯度下降。

現在我們將建立一個方法來新增截距項：

def add_intercept_term(self,X):
        X = np.insert(X,1,np.ones(X.shape[0:1]),axis=1).copy()
        return X

這基本上是在我們的特徵開始處插入一個列。它只是為了矩陣乘法。

如果我們不加上這一點，那麼我們將迫使超平面通過原點，導致它大幅度傾斜，從而無法正確擬合數據

縮放我們的特徵：

def feature_scale(self,X):
        X = (X - X.mean()) / (X.std())
        return X

接下來，我們將隨機初始化權重：

def initialise_thetas(self):
        np.random.seed(42)
        self.thetas = np.random.rand(self.X.shape[1])

現在，我們將使用以下公式從頭開始編寫標準方程：

def normal_equation(self):
        A = np.linalg.inv(np.dot(self.X.T,self.X))
        B = np.dot(self.X.T,self.y)
        thetas = np.dot(A,B)
        return thetas

基本上，我們將演算法分為三個部分：

1. 我們得到了X轉置後與X的點積的逆

2. 我們得到重量和標籤的點積

3. 我們得到兩個計算值的點積

這就是標準方程！還不錯！現在，我們將使用以下公式實現批量梯度下降：

def batch_gradient_descent(self,alpha,n_iterations):
        self.cost_history = [0] * (n_iterations)
        self.n_iterations = n_iterations
        
        for i in range(n_iterations):
            h = np.dot(self.X,self.thetas.T)
            gradient = alpha * (1/self.m) * ((h - self.y)).dot(self.X)
            
            self.thetas = self.thetas - gradient
            self.cost_history[i] = mse(np.dot(self.X,self.thetas.T),self.y)
            
        return self.thetas

在這裡，我們執行以下操作：

1. 我們設定alpha，或者學習率，和迭代次數

2. 我們建立一個列表來儲存我們的成本函式歷史記錄，以便以後在折線圖中繪製

3. 迴圈n_iterations 次，

4. 我們得到預測，並計算梯度（函式切線的斜率）。

5. 我們更新權重以沿梯度負方向移動

6. 我們使用我們的自定義MSE函式記錄值

7. 重複，完成後，返回結果

讓我們定義一個擬合函式來擬合我們的資料：

def fit(self,bgd=False,alpha=0.158,n_iterations=4000):
        self.X = self.add_intercept_term(self.X)
        self.X = self.feature_scale(self.X)
        if bgd == False:
            
            self.thetas = self.normal_equation()
        else:
            self.bgd = True
            self.initialise_thetas()
            self.thetas = self.batch_gradient_descent(alpha,n_iterations)

在這裡，我們只需要檢查使用者是否需要梯度下降，並相應地執行我們的步驟。

讓我們構建一個函式來繪製成本函式：

def plot_cost_function(self):
        
        if self.bgd == True:
            plt.plot(range((self.n_iterations)),self.cost_history)
            plt.xlabel('No. of iterations')
            plt.ylabel('Cost Function')
            plt.title('Gradient Descent Cost Function Line Plot')
            plt.show()
        else:
            print('Batch Gradient Descent was not used!')

最後一種預測未標記例項的方法：

def predict(self,X_test):
        self.X_test = X_test.copy()
        self.X_test = self.add_intercept_term(self.X_test)
        self.X_test = self.feature_scale(self.X_test)
        predictions = np.dot(self.X_test,self.thetas.T)
        return predictions

現在，讓我們看看哪個優化產生了更好的結果。首先，讓我們試試梯度下降：

lin_reg_bgd = LinReg(X_train,y_train)
lin_reg_bgd.fit(bgd=True)

mse(y_test,lin_reg_bgd.predict(X_test))

OUT:
28.824024414708344

讓我們畫出我們的函式，看看成本函式是如何減少的：

所以我們可以看到，在大約1000次迭代時，它開始收斂。

現在的標準方程是：

lin_reg_normal = LinReg(X_train,y_train)
lin_reg_normal.fit()

mse(y_test,lin_reg_normal.predict(X_test))

OUT:
22.151417764247284

所以我們可以看到，標準方程的效能略優於梯度下降法。這可能是因為資料集很小，而且我們沒有為學習率選擇最佳引數。

未來

1. 大幅度提高學習率。會發生什麼？

2. 不應用特徵縮放。有區別嗎？

3. 嘗試研究一下，看看你能不能實現一個更好的優化演算法。在測試集中評估你的模型

寫這篇文章真的很有趣，雖然有點長，但我希望你今天學到了一些東西。

原文連結：https://towardsdatascience.com/machine-learning-algorithms-from-start-to-finish-in-python-linear-regression-aa8c1d6b1169

歡迎關注磐創AI部落格站：
http://panchuang.net/

sklearn機器學習中文官方文件：
http://sklearn123.com/

歡迎關注磐創部落格資源彙總站：
http://docs.panchuang.net/