谷歌的自動駕駛汽車和機器人研發之路受到很多阻礙，但該公司真正的未來是機器學習，這種技術使計算機變得更加智慧和個性化。
—— Eric Schmidt (谷歌主席)
我們可能生活在人類歷史上最具決定性的時期。計算機正從大型主機過渡到 PC 再過渡到雲端計算。但它的定義不是發生了什麼，而是未來幾年將要發生什麼。
對於像我這樣的人來說，這一時期最令人興奮的是工具和技術的民主化，隨之而來的是計算機的發展。今天，作為一名資料科學家，我能在幾個小時內透過使用複雜演算法來構建一個資料壓縮模型。但是，取得這樣的成績並不容易！我經歷了很多的辛苦！
誰會從這篇指南中受益？
我今天寫得這篇指南可能是我寫過的最有價值的一篇。
寫這份指南背後的目的是為資料科學家和機器學習愛好者提供一些便利。透過這個指南，我相信你能夠更好地處理機器學習問題並從中積累經驗。我對各種機器學習演算法都提供了相應的 Python & R 程式碼。這些應該足以讓你大展身手了。
我會故意跳過這些技術背後的統計學知識，因為你不需要一開始就理解它們。所以，如果你想深入瞭解這些演算法的理論知識，可以檢視其它資料。但是，如果你想開始構建機器學習專案，那麼這值得一試。
一般來說，機器學習演算法分為三種型別。
1. 監督式學習
工作原理：該演算法由一個目標/結果變數（或因變數）組成，該變數（或因變數）由給定的一組預測器（自變數）進行預測得到。使用這些變數集，我們可以生成輸入對映到期望輸出的函式。透過訓練演算法模型，讓模型在訓練資料上得到期望的準確度。監督學習的例子包括：迴歸、決策樹、隨機森林、KNN、Logistic 迴歸等。
2. 非監督式學習
工作原理：該演算法沒有任何目標/結果變數（或因變數）來預測或估計。它用於對樣本中的不同類別進行聚類，廣泛用於在不知道標籤的情況下對不同群體進行劃分。無監督學習的例子包括：Apriori 演算法，k-均值。
3. 增強學習
工作原理：機器被訓練來做出特定的決定。它是這樣工作的：機器透過反覆試驗不斷訓練自己，從過去的經驗中學習，並試圖運用最好的知識，作出準確的決策。強化學習的例子包括：馬爾可夫（Markov）決策過程。
常用的機器學習演算法列表
下面列舉了常用的機器學習演算法。這些演算法可以應用於所有的資料問題：
- 線性迴歸
-
邏輯迴歸
-
決策樹
-
SVM
-
樸素貝葉斯
-
k 近鄰
-
k-聚類
-
隨機森林
-
降維演算法
-
梯度提升演算法
- GBM
-
XGBoost
-
LightGBM
-
CatBoost
1. 線性迴歸
線性迴歸（Linear Regression）基於連續變數（s）的實數值估計（房屋價格，通話數量，總銷售額等）。在這裡，我們透過擬合一條最佳直線來建立自變數（x）和因變數（y）之間的關係。這個最佳擬合線稱為迴歸線，用線性方程 y= a * x+b 表示。
瞭解線性迴歸的最好方法是重溫一下童年的經歷。比如你讓五年級的孩子根據體重來班裡的同學進行排列，但是體重未知！你認為孩子會怎麼做？他們很可能會觀察（視覺分析）每個人的身高和體型，並用這些可見引數的組合來排列他們。這是現實生活中的線性迴歸！孩子實際上已經計算出身高和體型與體重的關係就類似於上面的方程式。
上式中，
- Y — 因變數
-
a — 斜率
-
X — 自變數
-
b — 截距
係數 a 和 b 是基於最小化資料點與迴歸線之間的距離之差的平方和而推導得到的。
請看下面的例子。我們已經確定了最佳擬合線具有線性方程 y= 0.2811x + 13.9。利用這個線性方程，如果得知一個人的身高，就能計算他的體重了。
線性迴歸主要有兩類：簡單線性迴歸和多元線性迴歸。簡單線性迴歸的特點是隻有一個自變數。多元線性迴歸的特徵是有多個（大於 1）獨立變數。當然，為了找到最佳擬合線，可以使用多項式擬合或曲線擬合，分別稱為多項式迴歸和曲線迴歸。
Pyhton 程式碼：
#Import Library
#Import other necessary libraries like pandas, numpy...
from sklearn import linear_model
#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train=input_variables_values_training_datasets
y_train=target_variables_values_training_datasets
x_test=input_variables_values_test_datasets
# Create linear regression object
linear = linear_model.LinearRegression()
# Train the model using the training sets and check score
linear.fit(x_train, y_train)
linear.score(x_train, y_train)
#Equation coefficient and Intercept
print('Coefficient: \n', linear.coef_)
print('Intercept: \n', linear.intercept_)
#Predict Output
predicted= linear.predict(x_test)
R 程式碼：
#Load Train and Test datasets
#Identify feature and response variable(s) and values must be numeric and numpy arrays
x_train <- input_variables_values_training_datasets
y_train <- target_variables_values_training_datasets
x_test <- input_variables_values_test_datasets
x <- cbind(x_train,y_train)
# Train the model using the training sets and check score
linear <- lm(y_train ~ ., data = x)
summary(linear)
#Predict Output
predicted= predict(linear,x_test)
2. 邏輯迴歸
不要被它的名字弄糊塗了！邏輯迴歸（Logistic Regression）是一種分類演算法而不是迴歸演算法。它根據給定的一組自變數估計離散值（二進位制值如 0/1、是/否、真/假）。簡單地說，它透過將資料擬合到 logit 函式來預測事件發生的機率。因此稱之為 logit 迴歸。因為它預測的是機率值，所以輸出介於 0 到 1 之間。
我們仍然透過一個簡單的例子來了解邏輯迴歸。
假設你的朋友問了你一個難題來解決。只有兩種結果：要麼解決，要麼沒有解決。現在想象一下，為了理解你擅長哪些科目，你正在接受各種各樣的謎題/測驗。這項研究的結果是這樣的：如果是初三的三角函式問題，你有 70% 的可能性解決它；另一方面，如果是五年級的歷史問題，你有 30% 的可能性解決它。這就是邏輯迴歸提供給你的東西。
來到數學上來，結果的對數機率就是預測變數的線性組合。
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence
ln(odds) = ln(p/(1-p))
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk
上面的程式碼中，p 是預測的機率。它的目標是最大化觀測樣本值的似然性，而不是像線性迴歸那樣最小化誤差的平方和。
你可能會問，為什麼要使用 log 函式？簡單來說，log 函式是代替階躍函式的最好選擇之一。為了節省篇幅，這裡就不再細說了。
Python 程式碼：
#Import Library
from sklearn.linear_model import LogisticRegression
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create logistic regression object
model = LogisticRegression()
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Equation coefficient and Intercept
print('Coefficient: \n', model.coef_)
print('Intercept: \n', model.intercept_)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
x <- cbind(x_train,y_train)
# Train the model using the training sets and check score
logistic <- glm(y_train ~ ., data = x,family='binomial')
summary(logistic)
#Predict Output
predicted= predict(logistic,x_test)
更多…
有許多方法可以提高模型效能：
- 互動作用項
-
移除特徵
-
正則化技術（https://www.analyticsvidhya.com/blog/2015/02/avoid-over-fitting-regularization/）
-
使用更復雜的模型
3. 決策樹
這是我最喜歡的演算法之一，我經常使用它。決策樹（Decision Tree）是主要用於分類問題的監督式學習演算法。令人驚喜的是，它因變數可以是離散的也可以是連續的。在該演算法中，我們將資料劃分成兩個或更多的組。劃分的準則是基於最重要的屬性/自變數，儘可能讓不同組別之間的差別大一些。有關更多細節，您可以閱讀：決策樹簡化教程：
在上面這張圖中，你可以看到，根據多個屬性，樣本（總的人數）最終被劃分為四個不同的組，以標識 Play 或者 Don’t Play。實現不同分組的方法有很多，例如 Gini、資訊增益、卡方、熵。
瞭解決策樹是如何運作的最好方法是玩 Jezzball —— 一個經典的微軟遊戲（下圖）。基本上，你有一個房間有移動的牆壁，你需要建立牆壁，以便最大面積得到清除的球。
所以，每次你用牆拆開房間時，試圖在同一個房間裡創造 2 個不同的組別。這與決策樹的工作原理非常類似。
更多決策樹的知識請查閱：
Python 程式碼：
#Import Library
#Import other necessary libraries like pandas, numpy...
from sklearn import tree
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create tree object
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini
# model = tree.DecisionTreeRegressor() for regression
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(rpart)
x <- cbind(x_train,y_train)
# grow tree
fit <- rpart(y_train ~ ., data = x,method="class")
summary(fit)
#Predict Output
predicted= predict(fit,x_test)
4. SVM（支援向量機）
SVM 是一種分類演算法。在這個演算法中，我們將每個資料項繪製為 n 維空間中的一個點（其中 n 是特徵個數），每個特徵都對應特定的座標。
例如，如果我們只有像身高和頭髮長度這兩個特徵的資料集，就可以在二維空間中繪製資料分佈，其中每個點有兩個座標（這些座標稱為支援向量）。
現在，我們尋找一條直線來劃分這兩類資料。可選擇的直線很多，但是最好的一條應該是能夠使兩類中最靠近直線的點距離最遠。
在上圖所示，直觀感覺最好的分類直線是中間那條，因為兩類中最靠近該直線的點的距離是最遠的。這條線就是我們的分類器。然後，測試資料落在該直線的哪一邊，就可以判定資料屬於哪一類。
更多 SVM 的知識請查閱：
https://www.analyticsvidhya.com/blog/2014/10/support-vector-machine-simplified/
如果使用 SVM 來處理上面的 Jezzball 遊戲，可以這麼思考：
- 你可以繪製任意斜率的直線或平面，而不一定是水平或垂直的。
-
遊戲的目標是在不同的房間裡分離不同顏色的球。
-
球是不移動的。
Python 程式碼：
#Import Library
from sklearn import svm
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create SVM classification object
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.
# Train the model using the training sets and check score
model.fit(X, y)
model.score(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(e1071)
x <- cbind(x_train,y_train)
# Fitting model
fit <-svm(y_train ~ ., data = x)
summary(fit)
#Predict Output
predicted= predict(fit,x_test)
5. 樸素貝葉斯
樸素貝葉斯（Naive Bayes）是一種基於貝葉斯定理的分類演算法，具有預測因子之間相互獨立的假設。簡單來說，樸素貝葉斯分類器假定特徵之間是相互獨立的，特徵之間沒有相互影響。例如，某個水果可以被認為是一個蘋果，是由它是紅色的，圓的，直徑約 3 英寸這三個特徵得到的。即使實際上這些特徵相互依賴或者相互影響，樸素貝葉斯分類器也會假設所有這些屬性都是相互獨立的，以此來增大這種水果是蘋果的機率。
樸素貝葉斯模型構建很容易，且特別適用於非常大的資料集。除了簡單之外，樸素貝葉斯模型的效能甚至比一些高度複雜的分類演算法還要好。
樸素貝葉斯提供了一種使用 P(c)、P(x) 和 P(x|c) 來計算後驗機率 P(c|x) 的方法，公式如下：
這裡，
- P(c|x) 是後驗機率
-
P(c) 是先驗機率
-
P(x|c) 是給定類別下 c 下的是預測器 x 的機率
-
P(x) 是預測器的機率
用一個例子來幫助我們理解。有一個訓練資料集，自變數是天氣狀況，因變數是 Play 和 Don’t Play。現在，我們需要根據天氣情況來判斷玩家是否 Play 遊戲。演算法步驟如下：
步驟一：將資料集轉換為頻率表。
步驟二：計算各種機率值，例如天陰的機率是 0.29，Play 的機率是 0.64。
步驟三：使用樸素貝葉斯公式來計算每個類的後驗機率。具有最高後驗機率的類就是預測的結果。
現在有個問題：如果天氣晴朗，玩家會 Play 遊戲，這個說法是正確的嗎？
根據樸素貝葉斯公式，有：
P(Yes|Sunny) = P(Sunny|Yes) * P(Yes) / P(Sunny)
根據上圖表中的內容，可得：
P(Sunny|Yes) = 3/9 = 0.33
P(Sunny) = 5/14 = 0.36
P(Yes)= 9/14 = 0.64
則計算得到：
P(Yes|Sunny) = 0.33 * 0.64 / 0.36 = 0.60
P(Yes|Sunny) 具有較高的機率，所以上面這句話是正確的。
樸素貝葉斯使用類似的方法來預測基於不同屬性的不同類別的機率。該演算法主要用於文字分類和多分類問題。
Python 程式碼：
#Import Library
from sklearn.naive_bayes import GaussianNB
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(e1071)
x <- cbind(x_train,y_train)
# Fitting model
fit <-naiveBayes(y_train ~ ., data = x)
summary(fit)
#Predict Output
predicted= predict(fit,x_test)
6. k 近鄰演算法
k 近鄰演算法（kNN）可以用於分類問題和迴歸問題，它在分類問題中得到了更廣泛的應用。k 近鄰是一種簡單的演算法，訓練時儲存所有樣本資料，測試時使用距離衡量法，透過 k 個最近的鄰居進行投票的方式對新樣本進行分類。
衡量距離的函式可以是 Euclidean 距離、Manhattan 距離、Minkowski 距離、Hamming 距離。前三個用於連續函式，第四個用於分類變數。如果 k＝1，則將該判定為與其最近鄰的類。有時，選擇合適的 k 值非常重要，通常可以使用交叉驗證來選擇。
k 近鄰演算法可以很容易地對映到我們的真實生活中。例如你想了解一個完全不熟悉的人，你可能會了解他的密友和他所進入的圈子，並獲得他/她的一些資訊！
選擇使用 k 近鄰演算法之前應該作以下考慮：
- k 近鄰演算法計算成本高
-
自變數應該歸一化，否則較大的數值範圍會讓模型產生偏差。
-
去除樣本集中的離群點和噪聲
Python 程式碼：
#Import Library
from sklearn.neighbors import KNeighborsClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create KNeighbors classifier object model
KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(knn)
x <- cbind(x_train,y_train)
# Fitting model
fit <-knn(y_train ~ ., data = x,k=5)
summary(fit)
#Predict Output
predicted= predict(fit,x_test)
7. k-Means
k-Means 是一種解決聚類問題的無監督演算法。其過程遵循一種簡單易行的方法，透過特定數量的叢集（例如 k 個叢集）對給定的資料集進行分類。叢集內的資料點是同一的，不同叢集之間的資料點是非均一的。
記得從墨跡中找出形狀嗎？k-Means 也是類似的做法。你檢視不同的形狀有哪些，並使用 k-Means 根據不同的形狀進行分類。
k-Means 演算法流程：
- 隨機為每個叢集挑選 k 個點，稱為質心。
-
每個資料選擇與它最近的質心，並標記為該類。
-
所有資料都聚類完之後，對每個類重新計算質心。
-
當產生新的質心時，重複第 2 步和第 3 步。
如何定義 k 值呢？
在 k-Means 中，我們有簇，每個簇都有它自己的質心。質心與該簇中的資料點之間的差的平方和構成了該簇的平方和。把所有簇的平方值和相加，就得到了該情況下總的平方和。
我們知道，隨著叢集數量 k 的增加，總的平方和會持續減小，如果把總的平方和繪製出來，可能會看到先是急劇減少，直到選擇某個值 k，下降緩慢得多。因此，我們可以根據這個找到最佳的簇數 k。
Python 程式碼：
#Import Library
from sklearn.cluster import KMeans
#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset
# Create KNeighbors classifier object model
k_means = KMeans(n_clusters=3, random_state=0)
# Train the model using the training sets and check score
model.fit(X)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(cluster)
fit <- kmeans(X, 3) # 5 cluster solution
8. 隨機森林
隨機森林（Random Forest）是決策樹集合。在隨機森林中，我們收集了許多決策樹（被稱為“森林”）。為了根據屬性對新物件進行分類，每個樹都給出分類，然後對這些樹的結果進行“投票”，最終選擇投票得數最多的哪一類別。
每棵樹按以下方法構建：
- 如果取 N 例訓練樣本作為來訓練每棵樹，則隨機抽取 N 例樣本，再有放回地進行下一次抽樣。每次抽樣得到的 N 個樣本作為一棵樹的訓練資料。
-
如果存在 M 個輸入變數（特徵值），則指定一個數字 m（遠小於 M），使得在每個節點處，隨機地從 M 中選擇 m 個特徵，並使用這些m 個特徵來對節點進行最佳分割。在森林生長過程中，m 的值保持不變。
-
每棵樹都儘可能自由生長。沒有修剪。
關於此演算法的更多細節，請參閱以下文章：
https://www.analyticsvidhya.com/blog/2014/06/introduction-random-forest-simplified/
(https://www.analyticsvidhya.com/blog/2014/06/comparing-cart-random-forest-1/)[https://www.analyticsvidhya.com/blog/2014/06/comparing-cart-random-forest-1/]
https://www.analyticsvidhya.com/blog/2014/06/comparing-random-forest-simple-cart-model/
https://www.analyticsvidhya.com/blog/2015/06/tuning-random-forest-model/
Python 程式碼：
#Import Library
from sklearn.ensemble import RandomForestClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create Random Forest object
model= RandomForestClassifier()
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(randomForest)
x <- cbind(x_train,y_train)
# Fitting model
fit <- randomForest(Species ~ ., x,ntree=500)
summary(fit)
#Predict Output
predicted= predict(fit,x_test)
9. 降維演算法
在過去的 4-5 年，資料捕獲在每一個可能的階段都有指數增長。企業/政府機構/研究機構不僅提供新的資料來源，而且獲取的資料也越來越詳細。
例如電子商務公司正在捕捉更多關於客戶的細節，比如他們的人口統計、網路爬行歷史、他們喜歡或不喜歡什麼、購買歷史、反饋和許多其他資訊，以便比最近的雜貨店老闆更能給予他們個性化的關注。
作為一名資料科學家，我們提供的資料包括許多特性，這聽起來有利於建立良好的健壯模型，但是存在一個問題：你如何識別出 1000 或 2000 個特徵中那些是最重要的呢？在這種情況下，降維演算法可以幫助我們及其他各種演算法，如決策樹、隨機森林、主成分分析、因子分析、基於相關矩陣的識別、缺失值比等。
關於降維演算法的更多內容，請參閱以下文章：
https://www.analyticsvidhya.com/blog/2015/07/dimension-reduction-methods/
Python 程式碼：
#Import Library
from sklearn import decomposition
#Assumed you have training and test data set as train and test
# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)
# For Factor analysis
#fa= decomposition.FactorAnalysis()
# Reduced the dimension of training dataset using PCA
train_reduced = pca.fit_transform(train)
#Reduced the dimension of test dataset
test_reduced = pca.transform(test)
#For more detail on this, please refer this link:http://scikit-learn.org/stable/modules/decomposition.html#decompositions
R 程式碼：
library(stats)
pca <- princomp(train, cor = TRUE)
train_reduced <- predict(pca,train)
test_reduced <- predict(pca,test)
10. 梯度提升演算法
10.1 GBM
GBM 是一種在處理大量資料以進行高預測的預測時使用的 Boosting 演算法。Boosting 實際上是一個學習演算法的集合，它結合了幾個基本估計量的預測，以便比單個估計量提高魯棒性。它將多個弱或平均預測因子組合成一個強預測因子。這些升力演算法在 Kaggle、AV Hakason、CrowdAnalytix 等資料科學競賽中一直表現不錯。
關於 GBM 的更多相關知識請參閱：
https://www.analyticsvidhya.com/blog/2015/05/boosting-algorithms-simplified/
Python 程式碼：
#Import Library
from sklearn.ensemble import GradientBoostingClassifier
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
# Create Gradient Boosting Classifier object
model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
# Train the model using the training sets and check score
model.fit(X, y)
#Predict Output
predicted= model.predict(x_test)
R 程式碼：
library(caret)
x <- cbind(x_train,y_train)
# Fitting model
fitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)
fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)
predicted= predict(fit,x_test,type= "prob")[,2]
梯度提升分類器和隨機森林是兩種不同的 boosting 樹分類器，兩種演算法的區別請參閱：
10.2 XGBoost
另一個經典的梯度提升演算法 XGBoost 是在一些 kaggle 比賽中決定勝負的關鍵。
XGBoost 具有非常高的預測能力，這使它成為事件準確度的最佳選擇，因為它同時具有線性模型和樹學習演算法，使得該演算法比現有的梯度增強器技術快近10倍。
XGBoost 支援包括各種目標函式，包括迴歸、分類和排序。
XGBoost 最有趣的事情之一是它也被稱為一種正則化的提升技術。這有助於減少過擬合。XGBoost 有許多語言提供支援，包括 Scala、Java、R、Python、Julia、C++ 等。
XGBoost 支援分散式計算，包括 GCE，AWS，Azure 和 Yarn 叢集。XGBoost 還可以與 Spark、Flink 和其他雲資料流系統整合，並在每次提升過程的迭代中內建交叉驗證。
有關 XGBoost 引數調整的更多資訊請參閱：
Python 程式碼：
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
X = dataset[:,0:10]
Y = dataset[:,10:]
seed = 1
X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.33, random_state=seed)
model = XGBClassifier()
model.fit(X_train, y_train)
#Make predictions for test data
y_pred = model.predict(X_test)
R 程式碼：
require(caret)
x <- cbind(x_train,y_train)
# Fitting model
TrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)
model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)
OR
model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)
predicted <- predict(model, x_test)
10.3 LightGBM
LightGBM 是一種基於樹的學習演算法的梯度提升框架。它被設計成分散式和高效的，具有以下優點：
- 更快的訓練速度和更高的效率
-
佔用記憶體少
-
準確率高
-
並行 GPU 支援
-
能夠處理大規模資料
該框架是一種基於決策樹演算法的快速高效的梯度提升演算法，用於排序、分類等機器學習任務。它是在微軟的分散式機器學習工具包專案下開發的。
由於 LightGBM 是基於決策樹演算法的，所以它以最佳擬合度按葉子方向分割樹，而其他增強演算法按層次或深度方向而不是按葉子方向分割樹。因此，在 LightGBM 中，當在同一片葉子上生長時，葉子方向演算法能夠比逐級搜尋（level-wise）演算法減少更多的損耗，從而產生比現有任何提升演算法都難以達到的更好的精度。
此外，它的速度非常快，因此使用 Light（光）這個詞。
更多 LightGBM 知識，請參閱以下文章：
https://www.analyticsvidhya.com/blog/2017/06/which-algorithm-takes-the-crown-light-gbm-vs-xgboost/
Python 程式碼：
data = np.random.rand(500, 10) # 500 entities, each contains 10 features
label = np.random.randint(2, size=500) # binary target
train_data = lgb.Dataset(data, label=label)
test_data = train_data.create_valid('test.svm')
param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}
param['metric'] = 'auc'
num_round = 10
bst = lgb.train(param, train_data, num_round, valid_sets=[test_data])
bst.save_model('model.txt')
# 7 entities, each contains 10 features
data = np.random.rand(7, 10)
ypred = bst.predict(data)
R 程式碼：
library(RLightGBM)
data(example.binary)
#Parameters
num_iterations <- 100
config <- list(objective = "binary", metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)
#Create data handle and booster
handle.data <- lgbm.data.create(x)
lgbm.data.setField(handle.data, "label", y)
handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))
#Train for num_iterations iterations and eval every 5 steps
lgbm.booster.train(handle.booster, num_iterations, 5)
#Predict
pred <- lgbm.booster.predict(handle.booster, x.test)
#Test accuracy
sum(y.test == (y.pred > 0.5)) / length(y.test)
#Save model (can be loaded again via lgbm.booster.load(filename))
lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")
如果您熟悉 R 語言中的 Caret package，可以使用以下程式碼實現 LightGBM：
require(caret)
require(RLightGBM)
data(iris)
model <-caretModel.LGBM()
fit <- train(Species ~ ., data = iris, method=model, verbosity = 0)
print(fit)
y.pred <- predict(fit, iris[,1:4])
library(Matrix)
model.sparse <- caretModel.LGBM.sparse()
#Generate a sparse matrix
mat <- Matrix(as.matrix(iris[,1:4]), sparse = T)
fit <- train(data.frame(idx = 1:nrow(iris)), iris$Species, method = model.sparse, matrix = mat, verbosity = 0)
print(fit)
10.4 Catboost
Catboost 是來自於 Yandex 的開源機器學習演算法。它可以很容易地與谷歌的 TensorFlow 蘋果的 Core ML 等深度學習框架相結合。
CatBoost 最大的好處是它不需要像其他 ML 模型那樣進行廣泛的資料樣本訓練，而且可以處理各種資料格式，不會破壞模型的健壯性。
在執行 CatBoost 之前，務必確保已經處理了缺失資料。
Catboost 可以在不顯示型別轉換錯誤的情況下自動處理分類變數，這有助於集中精力更好地調優模型，而不是解決一些小錯誤。
更多 Catboost 知識，請參閱以下文章：
https://www.analyticsvidhya.com/blog/2017/08/catboost-automated-categorical-data/
Python 程式碼：
import pandas as pd
import numpy as np
from catboost import CatBoostRegressor
#Read training and testing files
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")
#Imputing missing values for both train and test
train.fillna(-999, inplace=True)
test.fillna(-999,inplace=True)
#Creating a training set for modeling and validation set to check model performance
X = train.drop(['Item_Outlet_Sales'], axis=1)
y = train.Item_Outlet_Sales
from sklearn.model_selection import train_test_split
X_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)
categorical_features_indices = np.where(X.dtypes != np.float)[0]
#importing library and building model
from catboost import CatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')
model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)
submission = pd.DataFrame()
submission['Item_Identifier'] = test['Item_Identifier']
submission['Outlet_Identifier'] = test['Outlet_Identifier']
submission['Item_Outlet_Sales'] = model.predict(test)
R 程式碼：
set.seed(1)
require(titanic)
require(caret)
require(catboost)
tt <- titanic::titanic_train[complete.cases(titanic::titanic_train),]
data <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)
drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")
x <- data[,!(names(data) %in% drop_columns)]y <- data[,c("Survived")]
fit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)
grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3, rsm = 0.95, border_count = 64)
report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)
print(report)
importance <- varImp(report, scale = FALSE)
print(importance)
結語：
到目前為止，我確信，你會對常用的機器學習演算法有所瞭解。這篇文章和提供的 Python 程式碼、R 程式碼希望能幫助你快速上手。如果你熱衷於掌握機器學習，請馬上開始吧。帶著問題，解釋並應用這些程式碼，你會發現無窮的樂趣！
原文出處：
https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/
