常用的機器學習演算法

㈠ 干貨 | 基礎機器學習演算法

本篇內容主要是面向機器學習初學者,介紹常見的機器學習演算法，當然,歡迎同行交流。

哲學要回答的基本問題是從哪裡來、我是誰、到哪裡去，尋找答案的過程或許可以借鑒機器學習的套路：組織數據->挖掘知識->預測未來。組織數據即為設計特徵，生成滿足特定格式要求的樣本，挖掘知識即建模，而預測未來就是對模型的應用。

特徵設計依賴於對業務場景的理解，可分為連續特徵、離散特徵和組合高階特徵。本篇重點是機器學習演算法的介紹，可以分為監督學習和無監督學習兩大類。

無監督學習演算法很多，最近幾年業界比較關注主題模型，LSA->PLSA->LDA 為主題模型三個發展階段的典型演算法，它們主要是建模假設條件上存在差異。LSA假設文檔只有一個主題，PLSA 假設各個主題的概率分布不變（theta 都是固定的），LDA 假設每個文檔和詞的主題概率是可變的。

LDA 演算法本質可以藉助上帝擲骰子幫助理解，詳細內容可參加 Rickjin 寫的《 LDA 數據八卦》文章，淺顯易懂，順便也科普了很多數學知識，非常推薦。

監督學習可分為分類和回歸，感知器是最簡單的線性分類器，現在實際應用比較少，但它是神經網路、深度學習的基本單元。

線性函數擬合數據並基於閾值分類時，很容易受雜訊樣本的干擾，影響分類的准確性。邏輯回歸（Logistic Regression）利用 sigmoid 函數將模型輸出約束在 0 到 1 之間，能夠有效弱化雜訊數據的負面影響，被廣泛應用於互聯網廣告點擊率預估。

邏輯回歸模型參數可以通過最大似然求解，首先定義目標函數 L ( theta )，然後 log 處理將目標函數的乘法邏輯轉化為求和邏輯（最大化似然概率 -> 最小化損失函數），最後採用梯度下降求解。

相比於線性分類去，決策樹等非線性分類器具有更強的分類能力，ID3 和 C4.5 是典型的決策樹演算法，建模流程基本相似，兩者主要在增益函數（目標函數）的定義不同。

線性回歸和線性分類在表達形式上是類似的，本質區別是分類的目標函數是離散值，而回歸的目標函數是連續值。目標函數的不同導致回歸通常基於最小二乘定義目標函數，當然，在觀測誤差滿足高斯分布的假設情況下，最小二乘和最大似然可以等價。

當梯度下降求解模型參數時，可以採用 Batch 模式或者 Stochastic 模式，通常而言，Batch 模式准確性更高，Stochastic 模式復雜度更低。

上文已經提到，感知器雖然是最簡單的線性分類器，但是可以視為深度學習的基本單元，模型參數可以由自動編碼（ Auto Encoder ）等方法求解。

深度學習的優勢之一可以理解為特徵抽象，從底層特徵學習獲得高階特徵，描述更為復雜的信息結構。例如，從像素層特徵學習抽象出描述紋理結構的邊緣輪廓特徵，更進一步學習獲得表徵物體局部的更高階特徵。

俗話說三個臭皮匠賽過諸葛亮，無論是線性分類還是深度學習，都是單個模型演算法單打獨斗，有沒有一種集百家之長的方法，將模型處理數據的精度更進一步提升呢？當然，Model Ensembe l就是解決這個問題。Bagging 為方法之一，對於給定數據處理任務，採用不同模型/參數/特徵訓練多組模型參數，最後採用投票或者加權平均的方式輸出最終結果。

Boosting為Model Ensemble 的另外一種方法，其思想為模型每次迭代時通過調整錯誤樣本的損失權重提升對數據樣本整體的處理精度，典型演算法包括 AdaBoost 、GBDT 等。

不同的數據任務場景，可以選擇不同的 Model Ensemble 方法，對於深度學習，可以對隱層節點採用 DropOut 的方法實現類似的效果。

介紹了這么多機器學習基礎演算法，說一說評價模型優劣的基本准則。欠擬合和過擬合是經常出現的兩種情況，簡單的判定方法是比較訓練誤差和測試誤差的關系，當欠擬合時，可以設計更多特徵來提升模型訓練精度，當過擬合時，可以優化特徵量降低模型復雜度來提升模型測試精度。

特徵量是模型復雜度的直觀反映，模型訓練之前設定輸入的特徵量是一種方法，另外一種比較常用的方法是在模型訓練過程中，將特徵參數的正則約束項引入目標函數/損失函數，基於訓練過程篩選優質特徵。

模型調優是一個細致活，最終還是需要能夠對實際場景給出可靠的預測結果，解決實際問題。期待學以致用！ 作者 曉惑 本文轉自阿里技術，轉載需授權

㈡ 機器學習新手必看十大演算法

機器學習新手必看十大演算法
本文介紹了機器學習新手需要了解的 10 大演算法，包括線性回歸、Logistic 回歸、樸素貝葉斯、K 近鄰演算法等。
在機器學習中，有一種叫做「沒有免費的午餐」的定理。簡而言之，它指出沒有任何一種演算法對所有問題都有效，在監督學習(即預測建模)中尤其如此。
例如，你不能說神經網路總是比決策樹好，反之亦然。有很多因素在起作用，例如數據集的大小和結構。
因此，你應該針對具體問題嘗試多種不同演算法，並留出一個數據「測試集」來評估性能、選出優勝者。
當然，你嘗試的演算法必須適合你的問題，也就是選擇正確的機器學習任務。打個比方，如果你需要打掃房子，你可能會用吸塵器、掃帚或拖把，但是你不會拿出鏟子開始挖土。
大原則
不過也有一個普遍原則，即所有監督機器學習演算法預測建模的基礎。
機器學習演算法被描述為學習一個目標函數 f，該函數將輸入變數 X 最好地映射到輸出變數 Y：Y = f(X)
這是一個普遍的學習任務，我們可以根據輸入變數 X 的新樣本對 Y 進行預測。我們不知道函數 f 的樣子或形式。如果我們知道的話，我們將會直接使用它，不需要用機器學習演算法從數據中學習。
最常見的機器學習演算法是學習映射 Y = f(X) 來預測新 X 的 Y。這叫做預測建模或預測分析，我們的目標是盡可能作出最准確的預測。
對於想了解機器學習基礎知識的新手，本文將概述數據科學家使用的 top 10 機器學習演算法。
1. 線性回歸
線性回歸可能是統計學和機器學習中最知名和最易理解的演算法之一。
預測建模主要關注最小化模型誤差或者盡可能作出最准確的預測，以可解釋性為代價。我們將借用、重用包括統計學在內的很多不同領域的演算法，並將其用於這些目的。
線性回歸的表示是一個方程，它通過找到輸入變數的特定權重(稱為系數 B)，來描述一條最適合表示輸入變數 x 與輸出變數 y 關系的直線。
線性回歸
例如：y = B0 + B1 * x
我們將根據輸入 x 預測 y，線性回歸學習演算法的目標是找到系數 B0 和 B1 的值。
可以使用不同的技術從數據中學習線性回歸模型，例如用於普通最小二乘法和梯度下降優化的線性代數解。
線性回歸已經存在了 200 多年，並得到了廣泛研究。使用這種技術的一些經驗是盡可能去除非常相似(相關)的變數，並去除噪音。這是一種快速、簡單的技術，可以首先嘗試一下。
2. Logistic 回歸
Logistic 回歸是機器學習從統計學中借鑒的另一種技術。它是解決二分類問題的首選方法。
Logistic 回歸與線性回歸相似，目標都是找到每個輸入變數的權重，即系數值。與線性回歸不同的是，Logistic 回歸對輸出的預測使用被稱為 logistic 函數的非線性函數進行變換。
logistic 函數看起來像一個大的 S，並且可以將任何值轉換到 0 到 1 的區間內。這非常實用，因為我們可以規定 logistic 函數的輸出值是 0 和 1(例如，輸入小於 0.5 則輸出為 1)並預測類別值。
Logistic 回歸
由於模型的學習方式，Logistic 回歸的預測也可以作為給定數據實例(屬於類別 0 或 1)的概率。這對於需要為預測提供更多依據的問題很有用。
像線性回歸一樣，Logistic 回歸在刪除與輸出變數無關的屬性以及非常相似(相關)的屬性時效果更好。它是一個快速的學習模型，並且對於二分類問題非常有效。
3. 線性判別分析(LDA)
Logistic 回歸是一種分類演算法，傳統上，它僅限於只有兩類的分類問題。如果你有兩個以上的類別，那麼線性判別分析是首選的線性分類技術。
LDA 的表示非常簡單直接。它由數據的統計屬性構成，對每個類別進行計算。單個輸入變數的 LDA 包括：
每個類別的平均值;
所有類別的方差。
線性判別分析
進行預測的方法是計算每個類別的判別值並對具備最大值的類別進行預測。該技術假設數據呈高斯分布(鍾形曲線)，因此最好預先從數據中刪除異常值。這是處理分類預測建模問題的一種簡單而強大的方法。
4. 分類與回歸樹
決策樹是預測建模機器學習的一種重要演算法。
決策樹模型的表示是一個二叉樹。這是演算法和數據結構中的二叉樹，沒什麼特別的。每個節點代表一個單獨的輸入變數 x 和該變數上的一個分割點(假設變數是數字)。
決策樹
決策樹的葉節點包含一個用於預測的輸出變數 y。通過遍歷該樹的分割點，直到到達一個葉節點並輸出該節點的類別值就可以作出預測。
決策樹學習速度和預測速度都很快。它們還可以解決大量問題，並且不需要對數據做特別准備。
5. 樸素貝葉斯
樸素貝葉斯是一個簡單但是很強大的預測建模演算法。
該模型由兩種概率組成，這兩種概率都可以直接從訓練數據中計算出來：1)每個類別的概率;2)給定每個 x 的值，每個類別的條件概率。一旦計算出來，概率模型可用於使用貝葉斯定理對新數據進行預測。當你的數據是實值時，通常假設一個高斯分布(鍾形曲線)，這樣你可以簡單的估計這些概率。
貝葉斯定理
樸素貝葉斯之所以是樸素的，是因為它假設每個輸入變數是獨立的。這是一個強大的假設，真實的數據並非如此，但是，該技術在大量復雜問題上非常有用。
6. K 近鄰演算法
KNN 演算法非常簡單且有效。KNN 的模型表示是整個訓練數據集。是不是很簡單?
KNN 演算法在整個訓練集中搜索 K 個最相似實例(近鄰)並匯總這 K 個實例的輸出變數，以預測新數據點。對於回歸問題，這可能是平均輸出變數，對於分類問題，這可能是眾數(或最常見的)類別值。
訣竅在於如何確定數據實例間的相似性。如果屬性的度量單位相同(例如都是用英寸表示)，那麼最簡單的技術是使用歐幾里得距離，你可以根據每個輸入變數之間的差值直接計算出來其數值。
K 近鄰演算法
KNN 需要大量內存或空間來存儲所有數據，但是只有在需要預測時才執行計算(或學習)。你還可以隨時更新和管理訓練實例，以保持預測的准確性。
距離或緊密性的概念可能在非常高的維度(很多輸入變數)中會瓦解，這對演算法在你的問題上的性能產生負面影響。這被稱為維數災難。因此你最好只使用那些與預測輸出變數最相關的輸入變數。
7. 學習向量量化
K 近鄰演算法的一個缺點是你需要遍歷整個訓練數據集。學習向量量化演算法(簡稱 LVQ)是一種人工神經網路演算法，它允許你選擇訓練實例的數量，並精確地學習這些實例應該是什麼樣的。
學習向量量化
LVQ 的表示是碼本向量的集合。這些是在開始時隨機選擇的，並逐漸調整以在學習演算法的多次迭代中最好地總結訓練數據集。在學習之後，碼本向量可用於預測(類似 K 近鄰演算法)。最相似的近鄰(最佳匹配的碼本向量)通過計算每個碼本向量和新數據實例之間的距離找到。然後返回最佳匹配單元的類別值或(回歸中的實際值)作為預測。如果你重新調整數據，使其具有相同的范圍(比如 0 到 1 之間)，就可以獲得最佳結果。
如果你發現 KNN 在你的數據集上達到很好的結果，請嘗試用 LVQ 減少存儲整個訓練數據集的內存要求。
8. 支持向量機(SVM)
支持向量機可能是最受歡迎和最廣泛討論的機器學習演算法之一。
超平面是分割輸入變數空間的一條線。在 SVM 中，選擇一條可以最好地根據輸入變數類別(類別 0 或類別 1)對輸入變數空間進行分割的超平面。在二維中，你可以將其視為一條線，我們假設所有的輸入點都可以被這條線完全的分開。SVM 學習演算法找到了可以讓超平面對類別進行最佳分割的系數。
支持向量機
超平面和最近的數據點之間的距離被稱為間隔。分開兩個類別的最好的或最理想的超平面具備最大間隔。只有這些點與定義超平面和構建分類器有關。這些點被稱為支持向量，它們支持或定義了超平面。實際上，優化演算法用於尋找最大化間隔的系數的值。
SVM 可能是最強大的立即可用的分類器之一，值得一試。
9. Bagging 和隨機森林
隨機森林是最流行和最強大的機器學習演算法之一。它是 Bootstrap Aggregation(又稱 bagging)集成機器學習演算法的一種。
bootstrap 是從數據樣本中估算數量的一種強大的統計方法。例如平均數。你從數據中抽取大量樣本，計算平均值，然後平均所有的平均值以便更好的估計真實的平均值。
bagging 使用相同的方法，但是它估計整個統計模型，最常見的是決策樹。在訓練數據中抽取多個樣本，然後對每個數據樣本建模。當你需要對新數據進行預測時，每個模型都進行預測，並將所有的預測值平均以便更好的估計真實的輸出值。
隨機森林
隨機森林是對這種方法的一種調整，在隨機森林的方法中決策樹被創建以便於通過引入隨機性來進行次優分割，而不是選擇最佳分割點。
因此，針對每個數據樣本創建的模型將會與其他方式得到的有所不同，不過雖然方法獨特且不同，它們仍然是准確的。結合它們的預測可以更好的估計真實的輸出值。
如果你用方差較高的演算法(如決策樹)得到了很好的結果，那麼通常可以通過 bagging 該演算法來獲得更好的結果。
10. Boosting 和 AdaBoost
Boosting 是一種集成技術，它試圖集成一些弱分類器來創建一個強分類器。這通過從訓練數據中構建一個模型，然後創建第二個模型來嘗試糾正第一個模型的錯誤來完成。一直添加模型直到能夠完美預測訓練集，或添加的模型數量已經達到最大數量。
AdaBoost 是第一個為二分類開發的真正成功的 boosting 演算法。這是理解 boosting 的最佳起點。現代 boosting 方法建立在 AdaBoost 之上，最顯著的是隨機梯度提升。
AdaBoost
AdaBoost與短決策樹一起使用。在第一個決策樹創建之後，利用每個訓練實例上樹的性能來衡量下一個決策樹應該對每個訓練實例付出多少注意力。難以預測的訓練數據被分配更多權重，而容易預測的數據分配的權重較少。依次創建模型，每個模型在訓練實例上更新權重，影響序列中下一個決策樹的學習。在所有決策樹建立之後，對新數據進行預測，並且通過每個決策樹在訓練數據上的精確度評估其性能。
因為在糾正演算法錯誤上投入了太多注意力，所以具備已刪除異常值的干凈數據非常重要。
總結
初學者在面對各種機器學習演算法時經常問：「我應該用哪個演算法?」這個問題的答案取決於很多因素，包括：(1)數據的大小、質量和特性;(2)可用的計算時間;(3)任務的緊迫性;(4)你想用這些數據做什麼。
即使是經驗豐富的數據科學家在嘗試不同的演算法之前，也無法分辨哪種演算法會表現最好。雖然還有很多其他的機器學習演算法，但本篇文章中討論的是最受歡迎的演算法。如果你是機器學習的新手，這將是一個很好的學習起點。

㈢ 機器學習一般常用的演算法有哪些

機器學習是人工智慧的核心技術，是學習人工智慧必不可少的環節。機器學習中有很多演算法，能夠解決很多以前難以企的問題，機器學習中涉及到的演算法有不少，下面小編就給大家普及一下這些演算法。

一、線性回歸

一般來說，線性回歸是統計學和機器學習中最知名和最易理解的演算法之一。這一演算法中我們可以用來預測建模，而預測建模主要關注最小化模型誤差或者盡可能作出最准確的預測，以可解釋性為代價。我們將借用、重用包括統計學在內的很多不同領域的演算法，並將其用於這些目的。當然我們可以使用不同的技術從數據中學習線性回歸模型，例如用於普通最小二乘法和梯度下降優化的線性代數解。就目前而言，線性回歸已經存在了200多年，並得到了廣泛研究。使用這種技術的一些經驗是盡可能去除非常相似（相關）的變數，並去除噪音。這是一種快速、簡單的技術。

二、Logistic 回歸

它是解決二分類問題的首選方法。Logistic 回歸與線性回歸相似，目標都是找到每個輸入變數的權重，即系數值。與線性回歸不同的是，Logistic 回歸對輸出的預測使用被稱為 logistic 函數的非線性函數進行變換。logistic 函數看起來像一個大的S，並且可以將任何值轉換到0到1的區間內。這非常實用，因為我們可以規定logistic函數的輸出值是0和1並預測類別值。像線性回歸一樣，Logistic 回歸在刪除與輸出變數無關的屬性以及非常相似的屬性時效果更好。它是一個快速的學習模型，並且對於二分類問題非常有效。

三、線性判別分析（LDA）

在前面我們介紹的Logistic 回歸是一種分類演算法，傳統上，它僅限於只有兩類的分類問題。而LDA的表示非常簡單直接。它由數據的統計屬性構成，對每個類別進行計算。單個輸入變數的 LDA包括兩個，第一就是每個類別的平均值，第二就是所有類別的方差。而在線性判別分析，進行預測的方法是計算每個類別的判別值並對具備最大值的類別進行預測。該技術假設數據呈高斯分布，因此最好預先從數據中刪除異常值。這是處理分類預測建模問題的一種簡單而強大的方法。

四、決策樹

決策樹是預測建模機器學習的一種重要演算法。決策樹模型的表示是一個二叉樹。這是演算法和數據結構中的二叉樹，沒什麼特別的。每個節點代表一個單獨的輸入變數x和該變數上的一個分割點。而決策樹的葉節點包含一個用於預測的輸出變數y。通過遍歷該樹的分割點，直到到達一個葉節點並輸出該節點的類別值就可以作出預測。當然決策樹的有點就是決策樹學習速度和預測速度都很快。它們還可以解決大量問題，並且不需要對數據做特別准備。

五、樸素貝葉斯

其實樸素貝葉斯是一個簡單但是很強大的預測建模演算法。而這個模型由兩種概率組成，這兩種概率都可以直接從訓練數據中計算出來。第一種就是每個類別的概率，第二種就是給定每個 x 的值，每個類別的條件概率。一旦計算出來，概率模型可用於使用貝葉斯定理對新數據進行預測。當我們的數據是實值時，通常假設一個高斯分布，這樣我們可以簡單的估計這些概率。而樸素貝葉斯之所以是樸素的，是因為它假設每個輸入變數是獨立的。這是一個強大的假設，真實的數據並非如此，但是，該技術在大量復雜問題上非常有用。所以說，樸素貝葉斯是一個十分實用的功能。

六、K近鄰演算法

K近鄰演算法簡稱KNN演算法，KNN 演算法非常簡單且有效。KNN的模型表示是整個訓練數據集。KNN演算法在整個訓練集中搜索K個最相似實例（近鄰）並匯總這K個實例的輸出變數，以預測新數據點。對於回歸問題，這可能是平均輸出變數，對於分類問題，這可能是眾數類別值。而其中的訣竅在於如何確定數據實例間的相似性。如果屬性的度量單位相同，那麼最簡單的技術是使用歐幾里得距離，我們可以根據每個輸入變數之間的差值直接計算出來其數值。當然，KNN需要大量內存或空間來存儲所有數據，但是只有在需要預測時才執行計算。我們還可以隨時更新和管理訓練實例，以保持預測的准確性。

七、Boosting 和 AdaBoost

首先，Boosting 是一種集成技術，它試圖集成一些弱分類器來創建一個強分類器。這通過從訓練數據中構建一個模型，然後創建第二個模型來嘗試糾正第一個模型的錯誤來完成。一直添加模型直到能夠完美預測訓練集，或添加的模型數量已經達到最大數量。而AdaBoost 是第一個為二分類開發的真正成功的 boosting 演算法。這是理解 boosting 的最佳起點。現代 boosting 方法建立在 AdaBoost 之上，最顯著的是隨機梯度提升。當然，AdaBoost 與短決策樹一起使用。在第一個決策樹創建之後，利用每個訓練實例上樹的性能來衡量下一個決策樹應該對每個訓練實例付出多少注意力。難以預測的訓練數據被分配更多權重，而容易預測的數據分配的權重較少。依次創建模型，每一個模型在訓練實例上更新權重，影響序列中下一個決策樹的學習。在所有決策樹建立之後，對新數據進行預測，並且通過每個決策樹在訓練數據上的精確度評估其性能。所以說，由於在糾正演算法錯誤上投入了太多注意力，所以具備已刪除異常值的干凈數據十分重要。

八、學習向量量化演算法（簡稱 LVQ）

學習向量量化也是機器學習其中的一個演算法。可能大家不知道的是，K近鄰演算法的一個缺點是我們需要遍歷整個訓練數據集。學習向量量化演算法（簡稱 LVQ）是一種人工神經網路演算法，它允許你選擇訓練實例的數量，並精確地學習這些實例應該是什麼樣的。而學習向量量化的表示是碼本向量的集合。這些是在開始時隨機選擇的，並逐漸調整以在學習演算法的多次迭代中最好地總結訓練數據集。在學習之後，碼本向量可用於預測。最相似的近鄰通過計算每個碼本向量和新數據實例之間的距離找到。然後返回最佳匹配單元的類別值或作為預測。如果大家重新調整數據，使其具有相同的范圍，就可以獲得最佳結果。當然，如果大家發現KNN在大家數據集上達到很好的結果，請嘗試用LVQ減少存儲整個訓練數據集的內存要求

㈣ 機器學習中有哪些重要的優化演算法

梯度下降是非常常用的優化演算法。作為機器學習的基礎知識，這是一個必須要掌握的演算法。藉助本文，讓我們來一起詳細了解一下這個演算法。

前言

本文的代碼可以到我的Github上獲取：

https://github.com/paulQuei/gradient_descent

本文的演算法示例通過Python語言實現，在實現中使用到了numpy和matplotlib。如果你不熟悉這兩個工具，請自行在網上搜索教程。

關於優化

大多數學習演算法都涉及某種形式的優化。優化指的是改變x以最小化或者最大化某個函數的任務。

我們通常以最小化指代大多數最優化問題。最大化可經由最小化來實現。

我們把要最小化或最大化的函數成為目標函數（objective function）或准則（criterion）。

我們通常使用一個上標*表示最小化或最大化函數的x值，記做這樣：

[x^* = arg; min; f(x)]

優化本身是一個非常大的話題。如果有興趣，可以通過《數值優化》和《運籌學》的書籍進行學習。

模型與假設函數

所有的模型都是錯誤的，但其中有些是有用的。– George Edward Pelham Box

模型是我們對要分析的數據的一種假設，它是為解決某個具體問題從老洞數據中學習到的，因此它是機器學習最核心的概念。

針對一個問題，通常有大量的模型可以選擇。

本文不會深入討論這方面的內容，關於各種模型請參閱機器學習的相關書籍。本文僅以最簡單的線性模型為基礎來討論梯度下降演算法。

這里我們先介紹一下在監督學習（supervised learning）中常見的三個符號：

• m，描述訓練樣本的數量

• x，描述輸入變數或特徵

• y，描述輸出變數或者叫目標值

• 請注意，一個樣本笑或可能有很多的特徵，因此x和y通常是一個向量。不過在剛開始學習的時候，為了便於理解，你可以暫時理解為這就是一個具體的數值。

訓練集會包含很多的樣本，我們用 表示其中第i個樣本。

x是數據樣本的特徵，y是其目標值。例如，在預測房價的模型中，x是房子的各種信息，例如：面積，樓層，位置等等，y是房子的價格。在圖像識別的任務中，x是圖形的所有像素點數據，y是圖像中包含的目標對象。

我們是希望尋找一個函數，將x映射到y，這個函數要足夠的好，以至於能夠預測對應的y。由於歷史原因，這個函數叫做假設函數（hypothesis function）。

學習的過程如下圖所示。即：首先根據已有的數據（稱之為訓練集）訓練我們的演算法模型，然後根據模型的假設函數來進行新數據的預測。

線性模型（linear model）正如其名稱那樣：是希望通過一個直線的形式來描述模式。線性模型的假設函數如下所示：

[h_{ heta}(x) = heta_{0} + heta_{1} * x]

這個公式對於大家來說應該都是非常簡單的。如果把它繪制出來，其實就是一條直線。

下圖是一個具體的例子，即： 的圖形：

在實際的機器學習工程中碰含伍，你會擁有大量的數據。這些數據會來自於某個數據源。它們存儲在csv文件中，或者以其他的形式打包。

但是本文作為演示使用，我們通過一些簡單的代碼自動生成了需要的數據。為了便於計算，演示的數據量也很小。

import numpy as np

max_x = 10
data_size = 10
theta_0 = 5
theta_1 = 2

def get_data:
x = np.linspace(1, max_x, data_size)
noise = np.random.normal(0, 0.2, len(x))
y = theta_0 + theta_1 * x + noise
return x, y


這段代碼很簡單，我們生成了x范圍是 [1, 10] 整數的10條數據。對應的y是以線性模型的形式計算得到，其函數是：。現實中的數據常常受到各種因素的干擾，所以對於y我們故意加上了一些高斯雜訊。因此最終的y值為比原先會有輕微的偏離。

最後我們的數據如下所示：

x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [6.66, 9.11, 11.08, 12.67, 15.12, 16.76, 18.75, 21.35, 22.77, 24.56]


我們可以把這10條數據繪制出來這樣就有一個直觀的了解了，如下圖所示：

雖然演示用的數據是我們通過公式計算得到的。但在實際的工程中，模型的參數是需要我們通過數據學習到的。所以下文我們假設我們不知道這里線性模式的兩個參數是什麼，而是通過演算法的形式求得。

最後再跟已知的參數進行對比以驗證我們的演算法是否正確。

有了上面的數據，我們可以嘗試畫一條直線來描述我們的模型。

例如，像下面這樣畫一條水平的直線：

很顯然，這條水平線離數據太遠了，非常的不匹配。

那我們可以再畫一條斜線。

我們初次畫的斜線可能也不貼切，它可能像下面這樣：

最後我們通過不斷嘗試，找到了最終最合適的那條，如下所示：

梯度下降演算法的計算過程，就和這種本能式的試探是類似的，它就是不停的迭代，一步步的接近最終的結果。


代價函數

上面我們嘗試了幾次通過一條直線來擬合（fitting）已有的數據。

二維平面上的一條直線可以通過兩個參數唯一的確定，兩個參數的確定也即模型的確定。那如何描述模型與數據的擬合程度呢？答案就是代價函數。

代價函數（cost function）描述了學習到的模型與實際結果的偏差程度。以上面的三幅圖為例，最後一幅圖中的紅線相比第一條水平的綠線，其偏離程度（代價）應該是更小的。

很顯然，我們希望我們的假設函數與數據盡可能的貼近，也就是說：希望代價函數的結果盡可能的小。這就涉及到結果的優化，而梯度下降就是尋找最小值的方法之一。

• 代價函數也叫損失函數。

對於每一個樣本，假設函數會依據計算出一個估算值，我們常常用來表示。即 。

很自然的，我們會想到，通過下面這個公式來描述我們的模型與實際值的偏差程度：

[(h_ heta(x^i) - y^i)^2 = (widehat{y}^{i} - y^i)^2 = ( heta_{0} + heta_{1} * x^{i} - y^{i})^2]

請注意， 是實際數據的值， 是我們的模型的估算值。前者對應了上圖中的離散點的y坐標，後者對應了離散點在直線上投影點的y坐標。

每一條數據都會存在一個偏差值，而代價函數就是對所有樣本的偏差求平均值，其計算公式如下所示：

[L( heta) = frac {1}{m} sum_{i=1}^{m}(h_ heta(x^i) - y^i)^2 = frac {1}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i})^2]

當損失函數的結果越小，則意味著通過我們的假設函數估算出的結果與真實值越接近。這也就是為什麼我們要最小化損失函數的原因。

• 不同的模型可能會用不同的損失函數。例如，logistic回歸的假設函數是這樣的：。其代價函數是這樣的：

藉助上面這個公式，我們可以寫一個函數來實現代價函數：

def cost_function(x, y, t0, t1):
cost_sum = 0
for i in range(len(x)):
cost_item = np.power(t0 + t1 * x[i] - y[i], 2)
cost_sum += cost_item
return cost_sum / len(x)


這個函數的代碼應該不用多做解釋，它就是根據上面的完成計算。

我們可以嘗試選取不同的 和 組合來計算代價函數的值，然後將結果繪制出來：

import numpy as np
import matplotlib.pyplot as plt

from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

theta_0 = 5
theta_1 = 2

def draw_cost(x, y):
fig = plt.figure(figsize=(10, 8))
ax = fig.gca(projection='3d')
scatter_count = 100
radius = 1
t0_range = np.linspace(theta_0 - radius, theta_0 + radius, scatter_count)
t1_range = np.linspace(theta_1 - radius, theta_1 + radius, scatter_count)
cost = np.zeros((len(t0_range), len(t1_range)))
for a in range(len(t0_range)):
for b in range(len(t1_range)):
cost[a][b] = cost_function(x, y, t0_range[a], t1_range[b])
t0, t1 = np.meshgrid(t0_range, t1_range)

ax.set_xlabel('theta_0')
ax.set_ylabel('theta_1')
ax.plot_surface(t0, t1, cost, cmap=cm.hsv)


在這段代碼中，我們對 和 各自指定了一個范圍進行100次的采樣，然後以不同的 組合對來計算代價函數的值。

如果我們將所有點的代價函數值繪制出來，其結果如下圖所示：

從這個圖形中我們可以看出，當 越接近 [5, 2]時其結果（偏差）越小。相反，離得越遠，結果越大。


直觀解釋

從上面這幅圖中我們可以看出，代價函數在不同的位置結果大小不同。

從三維的角度來看，這就和地面的高低起伏一樣。最高的地方就好像是山頂。

而我們的目標就是：從任意一點作為起點，能夠快速尋找到一條路徑並以此到達圖形最低點（代價值最小）的位置。

而梯度下降的演算法過程就和我們從山頂想要快速下山的做法是一樣的。

在生活中，我們很自然會想到沿著最陡峭的路往下行是下山速度最快的。如下面這幅圖所示：

針對這幅圖，細心的讀者可能很快就會有很多的疑問，例如：

• 對於一個函數，怎麼確定下行的方向？

• 每一步該往前走多遠？

• 有沒有可能停留在半山腰的平台上？

這些問題也就是本文接下來要討論的內容。


演算法描述

梯度下降演算法最開始的一點就是需要確定下降的方向，即：梯度。

我們常常用 來表示梯度。

對於一個二維空間的曲線來說，梯度就是其切線的方向。如下圖所示：

而對於更高維空間的函數來說，梯度由所有變數的偏導數決定。

其表達式如下所示：

[ abla f({ heta}) = ( frac{partial f({ heta})}{partial heta_1} , frac{partial f({ heta})}{partial heta_2} , ... , frac{partial f({ heta})}{partial heta_n} )]

在機器學習中，我們主要是用梯度下降演算法來最小化代價函數，記做：

[ heta ^* = arg min L( heta)]

其中，L是代價函數，是參數。

梯度下降演算法的主體邏輯很簡單，就是沿著梯度的方向一直下降，直到參數收斂為止。

記做：

[ heta ^{k + 1}_i = heta^{k}_i - lambda abla f( heta^{k})]

• 這里的下標i表示第i個參數。 上標k指的是第k步的計算結果，而非k次方。在能夠理解的基礎上，下文的公式中將省略上標k。

這里有幾點需要說明：

• 收斂是指函數的變化率很小。具體選擇多少合適需要根據具體的項目來確定。在演示項目中我們可以選擇0.01或者0.001這樣的值。不同的值將影響演算法的迭代次數，因為在梯度下降的最後，我們會越來越接近平坦的地方，這個時候函數的變化率也越來越小。如果選擇一個很小的值，將可能導致演算法迭代次數暴增。

• 公式中的 稱作步長，也稱作學習率（learning rate）。它決定了每一步往前走多遠，關於這個值我們會在下文中詳細講解。你可以暫時人為它是一個類似0.01或0.001的固定值。

• 在具體的項目，我們不會讓演算法無休止的運行下去，所以通常會設置一個迭代次數的最大上限。


線性回歸的梯度下降

有了上面的知識，我們可以回到線性模型代價函數的梯度下降演算法實現了。

首先，根據代價函數我們可以得到梯度向量如下：

[ abla f({ heta}) = (frac{partial L( heta)}{ partial heta_{0}}, frac{ partial L( heta)}{ partial heta_{1}}) = (frac {2}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) , frac {2}{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) x^{i})]

接著，將每個偏導數帶入迭代的公式中，得到：

[ heta_{0} := heta_{0} - lambda frac{partial L( heta_{0})}{ partial heta_{0}} = heta_{0} - frac {2 lambda }{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) heta_{1} := heta_{1} - lambda frac{partial L( heta_{1})}{ partial heta_{1}} = heta_{1} - frac {2 lambda }{m} sum_{i=1}^{m}( heta_{0} + heta_{1} * x^{i} - y^{i}) x^{i}]

由此就可以通過代碼實現我們的梯度下降演算法了，演算法邏輯並不復雜：

learning_rate = 0.01

def gradient_descent(x, y):
t0 = 10
t1 = 10
delta = 0.001
for times in range(1000):
sum1 = 0
sum2 = 0
for i in range(len(x)):
sum1 += (t0 + t1 * x[i] - y[i])
sum2 += (t0 + t1 * x[i] - y[i]) * x[i]
t0_ = t0 - 2 * learning_rate * sum1 / len(x)
t1_ = t1 - 2 * learning_rate * sum2 / len(x)
print('Times: {}, gradient: [{}, {}]'.format(times, t0_, t1_))
if (abs(t0 - t0_) < delta and abs(t1 - t1_) < delta):
print('Gradient descent finish')
return t0_, t1_
t0 = t0_
t1 = t1_
print('Gradient descent too many times')
return t0, t1


這段代碼說明如下：

• 我們隨機選擇了 都為10作為起點

• 設置最多迭代1000次

• 收斂的范圍設為0.001

• 學習步長設為0.01

如果我們將演算法迭代過程中求得的線性模式繪制出來，可以得到下面這幅動態圖：

最後演算法得到的結果如下：


Times: 657, gradient: [5.196562662718697, 1.952931052920264]
Times: 658, gradient: [5.195558390180733, 1.9530753071808193]
Times: 659, gradient: [5.194558335124868, 1.9532189556399233]
Times: 660, gradient: [5.193562479839619, 1.9533620008416623]
Gradient descent finish


從輸出中可以看出，演算法迭代了660次就收斂了。這時的結果[5.193562479839619, 1.9533620008416623]，這已經比較接近目標值 [5, 2]了。如果需要更高的精度，可以將delta的值調的更小，當然，此時會需要更多的迭代次數。


高維擴展

雖然我們舉的例子是二維的，但是對於更高維的情況也是類似的。同樣是根據迭代的公式進行運算即可：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - frac{2lambda}{m} sum_{i=1}^{m}(h_ heta(x^{k})-y^k)x_i^k]

這里的下標i表示第i個參數，上標k表示第k個數據。


梯度下降家族BGD

在上面的內容中我們看到，演算法的每一次迭代都需要把所有樣本進行遍歷處理。這種做法稱為之Batch Gradient Descent，簡稱BGD。作為演示示例只有10條數據，這是沒有問題的。

但在實際的項目中，數據集的數量可能是幾百萬幾千萬條，這時候每一步迭代的計算量就會非常的大了。

於是就有了下面兩個變種。


SGD

Stochastic Gradient Descent，簡稱SGD，這種演算法是每次從樣本集中僅僅選擇一個樣本來進行計算。很顯然，這樣做演算法在每一步的計算量一下就少了很多。

其演算法公式如下：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - lambda(h_ heta(x^k)-y^k)x_i^k]

當然，減少演算法計算量也是有代價的，那就是：演算法結果會強依賴於隨機取到的數據情況，這可能會導致演算法的最終結果不太令人滿意。


MBGD

以上兩種做法其實是兩個極端，一個是每次用到了所有數據，另一個是每次只用一個數據。

我們自然就會想到兩者取其中的方法：每次選擇一小部分數據進行迭代。這樣既避免了數據集過大導致每次迭代計算量過大的問題，也避免了單個數據對演算法的影響。

這種演算法稱之為Mini-batch Gradient Descent，簡稱MBGD。

其演算法公式如下：

[ heta_{i} = heta_{i} - lambda frac {partial L( heta)}{partial heta_i} = heta_{i} - frac{2lambda}{m} sum_{i=a}^{a + b}(h_ heta(x^k)-y^k)x_i^k]

當然，我們可以認為SGD是Mini-batch為1的特例。

針對上面提到的演算法變種，該如何選擇呢？

下面是Andrew Ng給出的建議：

• 如果樣本數量較小（例如小於等於2000），選擇BGD即可。

• 如果樣本數量很大，選擇 來進行MBGD，例如：64，128，256，512。

下表是 Optimization for Deep Learning 中對三種演算法的對比

方法准確性更新速度內存佔用在線學習BGD好慢高否SGD好（with annealing）快低是MBGD好中等中等是
演算法優化

式7是演算法的基本形式，在這個基礎上有很多人進行了更多的研究。接下來我們介紹幾種梯度下降演算法的優化方法。


Momentum

Momentum是動量的意思。這個演算法的思想就是藉助了動力學的模型：每次演算法的迭代會使用到上一次的速度作為依據。

演算法的公式如下：

[v^t = gamma v^{t - 1} + lambda abla f( heta) heta = heta - v_t]

對比式7可以看出，這個演算法的主要區別就是引入了，並且，每個時刻的受前一個時刻的影響。

從形式上看，動量演算法引入了變數 v 充當速度角色——它代表參數在參數空間移動的方向和速率。速度被設為負梯度的指數衰減平均。名稱動量來自物理類比，根據牛頓運動定律，負梯度是移動參數空間中粒子的力。動量在物理學上定義為質量乘以速度。在動量學習演算法中，我們假設是單位質量，因此速度向量 v 也可以看作是粒子的動量。

對於可以取值0，而是一個常量，設為0.9是一個比較好的選擇。

下圖是momentum演算法的效果對比：

對原來的演算法稍加修改就可以增加動量效果：

def gradient_descent_with_momentum(x, y):
t0 = 10
t1 = 10
delta = 0.001
v0 = 0
v1 = 0
gamma = 0.9
for times in range(1000):
sum1 = 0
sum2 = 0
for i in range(len(x)):
sum1 += (t0 + t1 * x[i] - y[i])
sum2 += (t0 + t1 * x[i] - y[i]) * x[i]
v0 = gamma * v0 + 2 * learning_rate * sum1 / len(x)
v1 = gamma * v1 + 2 * learning_rate * sum2 / len(x)
t0_ = t0 - v0
t1_ = t1 - v1
print('Times: {}, gradient: [{}, {}]'.format(times, t0_, t1_))
if (abs(t0 - t0_) < delta and abs(t1 - t1_) < delta):
print('Gradient descent finish')
return t0_, t1_
t0 = t0_
t1 = t1_
print('Gradient descent too many times')
return t0, t1


以下是該演算法的輸出：


Times: 125, gradient: [4.955453758569991, 2.000005017897775]
Times: 126, gradient: [4.955309381126545, 1.9956928964532015]
Times: 127, gradient: [4.9542964317327005, 1.9855674828684156]
Times: 128, gradient: [4.9536358220657, 1.9781180992510465]
Times: 129, gradient: [4.95412496254411, 1.9788858350530971]
Gradient descent finish


從結果可以看出，改進的演算法只用了129次迭代就收斂了。速度比原來660次快了很多。

同樣的，我們可以把演算法計算的過程做成動態圖：

對比原始的演算法過程可以看出，改進演算法最大的區別是：在尋找目標值時會在最終結果上下跳動，但是越往後跳動的幅度越小，這也就是動量所產生的效果。


Learning Rate 優化

至此，你可能還是好奇該如何設定學習率的值。

事實上，這個值的選取需要一定的經驗或者反復嘗試才能確定。

• 《深度學習》一書中是這樣描述的：「與其說是科學，這更像是一門藝術，我們應該謹慎地參考關於這個問題的大部分指導。」。

關鍵在於，這個值的選取不能過大也不能過小。

如果這個值過小，會導致每一次迭代的步長很小，其結果就是演算法需要迭代非常多的次數。

那麼，如果這個值過大會怎麼樣呢？其結果就是：演算法可能在結果的周圍來回震盪，卻落不到目標的點上。下面這幅圖描述了這個現象：

事實上，學習率的取值未必一定要是一個常數，關於這個值的設定有很多的研究。

下面是比較常見的一些改進演算法。


AdaGrad

AdaGrad是Adaptive Gradient的簡寫，該演算法會為每個參數設定不同的學習率。它使用歷史梯度的平方和作為基礎來進行計算。

其演算法公式如下：

[ heta_i = heta_i - frac{lambda}{sqrt{G_t + epsilon}} abla f( heta)]

對比式7，這里的改動就在於分號下面的根號。

根號中有兩個符號，第二個符號比較好理解，它就是為了避免除0而人為引入的一個很小的常數，例如可以設為：0.001。

第一個符號的表達式展開如下：

[G_t = sum_{i = 1}^{t} abla f( heta){i} abla f( heta){i}^{T}]

這個值其實是歷史中每次梯度的平方的累加和。

AdaGrad演算法能夠在訓練中自動的對learning rate進行調整，對於出現頻率較低參數採用較大的學習率；相反，對於出現頻率較高的參數採用較小的學習率。因此，Adagrad非常適合處理稀疏數據。

但該演算法的缺點是它可能導致學習率非常小以至於演算法收斂非常的慢。

關於這個演算法的直觀解釋可以看李宏毅教授的視頻課程：ML Lecture 3-1: Gradient Descent。


RMSProp

RMS是Root Mean Square的簡寫。RMSProp是AI教父Geoff Hinton提出的一種自適應學習率方法。AdaGrad會累加之前所有的梯度平方，而RMSProp僅僅是計算對應的平均值，因此可緩解Adagrad演算法學習率下降較快的問題。

該演算法的公式如下：

[E[ abla f( heta_{i})^2]^{t} = gamma E[ abla f( heta_{i})^2]^{t - 1} + (1-gamma)( abla f( heta_{i})^{t})^{2} heta_i = heta_i - frac{lambda}{sqrt{E[g^2]^{t+1} + epsilon}} abla f( heta_{i})]

類似的，是為了避免除0而引入。 是衰退參數，通常設為0.9。

這里的 是t時刻梯度平方的平均值。


Adam

Adam是Adaptive Moment Estimation的簡寫。它利用梯度的一階矩估計和二階矩估計動態調整每個參數的學習率。

Adam的優點主要在於經過偏置校正後，每一次迭代學習率都有個確定范圍，使得參數比較平穩。

該演算法公式如下：

[m^{t} = eta_{1} m^{t-1} + (1-eta_{1}) abla f( heta) v^{t} = eta_{2} v^{t-1} + (1-eta_{2}) abla f( heta)^2 widehat{m}^{t} = frac{m^{t}}{1 - eta^{t}_1} widehat{v}^{t} = frac{v^{t}}{1 - eta^{t}_2} heta = heta - frac{lambda}{sqrt{widehat{v}^{t}} + epsilon}widehat{m}^{t}]

，分別是對梯度的一階矩估計和二階矩估計。， 是對，的校正，這樣可以近似為對期望的無偏估計。

Adam演算法的提出者建議 默認值為0.9，默認值為0.999，默認值為 。

在實際應用中 ，Adam較為常用，它可以比較快地得到一個預估結果。


優化小結

這里我們列舉了幾種優化演算法。它們很難說哪種最好，不同的演算法適合於不同的場景。在實際的工程中，可能需要逐個嘗試一下才能確定選擇哪一個，這個過程也是目前現階段AI項目要經歷的工序之一。

實際上，該方面的研究遠不止於此，如果有興趣，可以繼續閱讀 《Sebastian Ruder: An overview of gradient descent optimization algorithms》 這篇論文或者 Optimization for Deep Learning 這個Slides進行更多的研究。

由於篇幅所限，這里不再繼續展開了。


演算法限制

梯度下降演算法存在一定的限制。首先，它要求函數必須是可微分的，對於不可微的函數，無法使用這種方法。

除此之外，在某些情況下，使用梯度下降演算法在接近極值點的時候可能收斂速度很慢，或者產生Z字形的震盪。這一點需要通過調整學習率來迴避。

另外，梯度下降還會遇到下面兩類問題。


局部最小值

局部最小值（Local Minima）指的是，我們找到的最小值僅僅是一個區域內的最小值，而並非全局的。由於演算法的起點是隨意取的，以下面這個圖形為例，我們很容易落到局部最小值的點裡面。

這就是好像你從上頂往下走，你第一次走到的平台未必是山腳，它有可能只是半山腰的一個平台的而已。

演算法的起點決定了演算法收斂的速度以及是否會落到局部最小值上。

壞消息是，目前似乎沒有特別好的方法來確定選取那個點作為起點是比較好的，這就有一點看運氣的成分了。多次嘗試不同的隨機點或許是一個比較好的方法，這也就是為什麼做演算法的優化這項工作是特別消耗時間的了。

但好消息是：

• 對於凸函數或者凹函數來說，不存在局部極值的問題。其局部極值一定是全局極值。

• 最近的一些研究表明，某些局部極值並沒有想像中的那麼糟糕，它們已經非常的接近全局極值所帶來的結果了。


鞍點

除了Local Minima，在梯度下降的過程中，還有可能遇到另外一種情況，即：鞍點（Saddle Point）。鞍點指的是我們找到點某個點確實是梯度為0，但它卻不是函數的極值，它的周圍既有比它小的值，也有比它大的值。這就好像馬鞍一樣。

如下圖所示：

多類隨機函數表現出以下性質：在低維空間中，局部極值很普遍。但在高維空間中，局部極值比較少見，而鞍點則很常見。

不過對於鞍點，可以通過數學方法Hessian矩陣來確定。關於這點，這里就不再展開了，有興趣的讀者可以以這里提供的幾個鏈接繼續探索。


參考資料與推薦讀物

• Wikipeida: Gradient descent

• Sebastian Ruder: An overview of gradient descent optimization algorithms

• 吳恩達：機器學習

• 吳恩達：深度學習

• Peter Flach：機器學習

• 李宏毅 - ML Lecture 3-1: Gradient Descent

• PDF: 李宏毅 - Gradient Descent

• Intro to optimization in deep learning: Gradient Descent

• Intro to optimization in deep learning: Momentum, RMSProp and Adam

• Stochastic Gradient Descent – Mini-batch and more

• 劉建平Pinard - 梯度下降（Gradient Descent）小結

• 多元函數的偏導數、方向導數、梯度以及微分之間的關系思考

• [Machine Learning] 梯度下降法的三種形式BGD、SGD以及MBGD

• 作者：阿Paul https://paul.pub/gradient-descent/

㈤ 機器學習演算法有哪些，最常用是哪些幾種，有什麼優點

樓主肯定對機器學習了解不多才會提這種問題。這問題專業程度看起來和「機器學習工程師」這詞彙一樣。
機器學習，基礎的PCA模型理論，貝葉斯，boost,Adaboost,
模式識別中的各種特徵，諸如Hog，Haar,SIFT等
深度學習里的DBN，CNN，BP，RBM等等。
非專業出身，只是略懂一點。

沒有常用的，只是針對需求有具體的設計，或者需要自己全新設計一個合適的演算法，現在最熱門的算是CNN(convolutional neural networks)卷積神經網路了。
優點:不需要訓練獲取特徵，在學習過程中自動提取圖像中的特徵，免去了常規方法中，大量訓練樣本的時間。在樣本足夠大的情況下，能夠得到非常精確的識別結果。一般都能95%+的正確率。
缺點：硬體要求高，CUDA的並行框架算是用的很火的了。但是一般的台式機跑一個Demo花費的時間長資源佔用高。不過這也是這塊演算法的通病。