轉自：https://www.ziiai.com/blog/706

原文：https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/

一般來說，有3種類型的機器學習演算法

1.監督學習

工作原理：該演算法由一個目標/結果變數（或因變數）組成，該變數（或因變數）由給定的一組預測器（自變數）進行預測。使用這些變數集，我們生成對映輸入到期望輸出的函式。訓練過程繼續進行，直到模型達到訓練資料所需的精度水平。監督學習演算法有：迴歸、決策樹、隨機森林、KNN、Logistic迴歸等。

2.無監督學習

它是如何工作的：在這個演算法中，我們沒有任何目標或結果變數來預測/估計。它用於對不同群體中的人群進行聚類，廣泛用於對不同群體中的客戶進行細分以進行特定干預。無監督學習的例子：Apriori演算法，k-均值。

3.強化學習：

它是如何工作的：使用這個演算法，機器被訓練來做出特定的決定。

它是這樣工作的：機器暴露在一個環境中，它通過反覆試驗不斷訓練自己。這臺機器從過去的經驗中學習，並試圖捕捉最好的知識，以作出準確的商業決策。

強化學習例項：馬爾可夫決策過程

常用機器學習演算法列表

下面是常用的機器學習演算法的列表。這些演算法可以應用於幾乎任何資料問題：

• 線性迴歸
• 對數機率迴歸
• 決策樹
• SVM
• 樸素貝葉斯
• KNN
• 聚類
• 隨機森林
• 降維演算法
• 梯度提升演算法

GBM（梯度提升機）

XGBOST

輕量級GBM

升壓

1.線性迴歸

它是用來估計實際價值（房屋成本，電話號碼，總銷售額等）的基礎上連續變數（S）。在這裡，我們建立一個最佳的線建立獨立變數和因變數之間的關係。這個最佳擬合線稱為迴歸線，用線性方程y= a*x+b表示。

瞭解線性迴歸的最好方法是重溫童年的經歷。讓我們說，你讓五年級的孩子通過體重升序來安排班上的同學，而不問他們的體重！你認為孩子會做什麼？他/她很可能會觀察（視覺分析）人的身高和體型，並用這些可見引數的組合來安排他們。這是現實生活中的線性迴歸！孩子實際上已經計算出身高和體型與體重的關係就像上面的方程式。

在這個方程式中：

Y——因變數

a——斜率

X——獨立變數

b——截距

這些係數a和b是基於最小化資料點與迴歸線之間的距離的平方差之和而匯出的。

請看下面的例子。在這裡，我們已經確定了最佳擬合線具有線性方程y= 0.2811x + 13.9。現在用這個方程式，我們可以知道重量，知道一個人的身高。

線性迴歸主要有兩類：簡單線性迴歸和多元線性迴歸。簡單線性迴歸的特點是一個獨立變數。多元線性迴歸（顧名思義）的特徵是多個（1個以上）獨立變數。在找到最佳擬合線時，可以擬合多項式或曲線迴歸。這些被稱為多項式或曲線迴歸。

Python 程式碼

#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.邏輯迴歸

不要被它的名字弄糊塗了！它是一種分類而不是迴歸演算法。它用於根據給定的一組自變數估計離散值（二進位制值如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是存在感興趣特徵的概率。它選擇使觀察樣本值的可能性最大化的引數，而不是使平方誤差之和最小（如普通迴歸）。

現在，你可能會問，為什麼要記日誌？為了簡單起見，我們姑且認為這是複製階躍函式的最好的數學方法之一。我可以更詳細地說，但這將打破這篇文章的目的。

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)

此外，為了改進模型，可以嘗試許多不同的步驟：

• 包括互動項
• 去除特徵
• 正則化技術
• 使用非線性模型

3.決策樹

這是我最喜歡的演算法之一，我經常使用它。它是一種主要用於分類問題的監督學習演算法。令人驚訝的是，它適用於分類和連續因變數。在該演算法中，我們將人口分成兩個或更多的齊次集。這是基於最重要的屬性變數/獨立變數，以儘可能不同的組。有關更多細節，您可以閱讀：決策樹簡化。

在上面的影象中，您可以看到，根據多個屬性，人口被劃分為四個不同的組，以標識“他們是否想玩”。為了將種群分成不同的異質群體，它使用如Gini、資訊增益、卡方、熵等各種技術。

瞭解決策樹是如何運作的最好方法是玩Jazzball——一個經典的微軟遊戲（下圖）。基本上，你有一個房間有移動的牆壁，你需要建立牆壁，以便最大面積得到清除的球。

所以，每次你用牆拆開房間時，你試圖在同一個房間裡創造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）

這是一種分類方法。在該演算法中，我們將每個資料項繪製為n維空間中的一個點（其中n是具有的特徵數），其中每個特徵的值是特定座標的值。

例如，如果我們只有像個體的高度和毛髮長度這樣的兩個特徵，我們首先在二維空間中繪製這兩個變數，其中每個點有兩個座標（這些座標稱為支援向量）

現在，我們將發現在兩個不同分類的資料組之間分割資料的一些線。這將是一條直線，使得兩組中最靠近的點的距離將最遠。

在上面所示的示例中，將資料分成兩個不同分類組的線是黑線，因為最接近的兩個點是離線最遠的。這條線是我們的分類器。然後，取決於測試資料落在行的哪一邊，這樣可以知道要將新資料分成什麼類。

更多：支援向量機的簡化版本

把這個演算法看作是在n維空間中玩Jazzball遊戲，遊戲中的調整是：

• 你可以在任何角度（不只是水平或垂直，如在經典遊戲）畫線/平面
• 遊戲的目的是在不同的房間中分離不同顏色的球
• 球不動

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.樸素貝葉斯

它是一種基於貝葉斯定理的分類技術，具有預測者之間的獨立性假設。簡單地說，樸素貝葉斯分類器假定類中的特定特徵的存在與任何其他特徵的存在無關。例如，水果如果是紅色的、圓的、直徑約3英寸的，那麼久可以被認為是一個蘋果。即使這些特徵彼此依賴或存在其他特徵，樸素貝葉斯分類器將考慮所有這些屬性來獨立地區分這種水果是蘋果的概率。

樸素貝葉斯模型易於建立，特別適用於非常大的資料集。雖然簡單，但樸素貝葉斯是已知的高效能甚至高度複雜的分類方法。

Bayes定理為P（C）、P（X）和P（X，C）的後驗概率p（C* x）的計算提供了一種途徑。請看下面的方程式：

在這裡，

• P（C x）是給定（屬性）的類（目標）的後驗概率。
• P（C）是類的先驗概率。
• P（x，c）是預測給定類的概率。
• P（x）是預測器的先驗概率。

例子：讓我們用一個例子來理解它。下面我有一個訓練資料集的天氣和相應的目標變數“玩”。現在，我們需要根據天氣情況來判斷玩家是否想玩。讓我們按照下面的步驟來執行它。

步驟1：將資料集轉換為頻率表

步驟二：通過發現陰暗概率＝0.29和概率為0.64的概率來建立似然表。

步驟三：使用樸素貝葉斯方程計算每個類的後驗概率。具有最高後驗概率的類是預測的結果。

問題：如果天氣晴朗，玩家會想玩，這個說法是正確的嗎？

我們可以用上面討論的方法求解它，所以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，具有較高的概率。

樸素貝葉斯使用類似的方法來預測基於不同屬性的不同類別的概率。該演算法主要用於文字分類，存在多類問題。

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.KNN（k-近鄰）

它可以用於分類和迴歸問題。然而，它在工業中的分類問題中得到了更廣泛的應用。K-近鄰是一種簡單的演算法，它儲存所有可用的案例，並通過k個鄰近的多數投票對新案例進行分類。被分配給類的情況是最常見的K-近鄰之間的距離函式測量。

這些距離函式可以是Euclidean, Manhattan, Minkowski 和 Hamming distance。前三個函式用於連續函式，第四個（Hamming）用於分類變數。如果k＝1，則將該情況簡單地分配給其最近鄰的類。有時，進行KNN建模時選擇K是一個挑戰。

更多：介紹K近鄰：簡化。

KNN可以很容易地對映到我們的真實生活中。如果你想了解一個你沒有資訊的人，你可能想了解他的密友和他所進入的圈子，並獲得他/她的資訊！

選擇KNN之前要考慮的事項：

• KNN在計算上是昂貴的
• 變數應該歸一化，否則較高的範圍變數會對它產生偏差。
• 在KNN類離群點、去噪前進行預處理階段的工作

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-均值演算法）

它是一種解決聚類問題的無監督演算法。其過程遵循一種簡單易行的方法，通過特定數量的叢集（假設k個叢集）對給定的資料集進行分類。叢集內的資料點對於對等組是均勻的和異構的。

還記得從墨跡中找出形狀嗎？K意味著某種類似的活動。你看這個形狀並散佈破譯有多少不同的叢集/人口存在！

k-均值如何形成叢集：

1. k-均值為每個叢集挑選K個點，稱為質心。
2. 每個資料點形成具有最接近質心的簇，即K簇。
3. 根據現有的群整合員查詢每個簇的質心。這裡我們有新的質心。
4. 當我們有新的質心時，重複第2步和第3步，從新的質心找到每個資料點最近的距離，並與新的K簇關聯。重複這個過程直到收斂發生，即質心不變。

如何確定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.隨機森林

隨機森林是決策樹集合的商標術語。在隨機森林中，我們收集了決策樹（被稱為“森林”）。為了根據屬性對新物件進行分類，每個樹都給出分類，並且我們稱樹為該類“投票”。森林選擇選票最多的分類（超過森林中的所有樹木）。

每棵樹被種植和生長如下：

1. 如果訓練集中的病例數為N，則隨機抽取N例樣本，但進行替換。這個樣本將是培養樹木的訓練工具。
2. 如果存在M個輸入變數，則指定一個數字m＞M，使得在每個節點處，隨機地從M中選擇m個變數，並使用這些m上的最佳分割來分割節點。在森林生長過程中，M的值保持不變。
3. 每棵樹的生長儘可能最大，沒有修剪。

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的高重要變數？在這種情況下，降維演算法可以和其他各種演算法如決策樹、隨機森林、主成分分析、因子分析、基於相關矩陣的識別、缺失值比等一起使用。

要了解更多的演算法，你可以閱讀“初學者指南學習降維技術”。

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.

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 Hackthon、CrowdAnalytix等資料科學競賽中總能表現得很好。

延展閱讀：瞭解更多提升演算法演算法

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] 

梯度提升分類器和隨機森林是兩種不同的提升樹分類器，人們經常問到這兩種演算法的區別。

10.2 XGBOST

另一種經典的梯度提升演算法，眾所周知，是一些Kaggle比賽中決定性選擇。

XGBoost具有非常高的預測能力，這使它成為事件準確度的最佳選擇，因為它同時具有線性模型和樹學習演算法，使得該演算法比現有的梯度提升機技術快近10倍。

支援包括各種目標函式，包括迴歸、分類和排序。

XGBoost最有趣的事情之一是它也被稱為一種正規的提升技術。這有助於減少過擬合建模，併為Scala、Java、R語言、Python、Julia和C++等多種語言提供了大量支援。

支援分散式和廣泛的訓練，包括GCE，AWS，Azure和 Yarn clusters等許多機器。XGBoost還可以與Spark、Flink和其他雲資料流系統整合，並在增強過程的每次迭代中內建交叉驗證。

要了解更多關於XGBoost和引數調優的資訊，請訪問https://www..ticsvidhya.com/blog/2016/03/.-.-.-tuning-xgboost-with-code-python/。

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是一種使用基於樹的學習演算法的梯度提升框架。它被設計成分散式和高效的，具有以下優點：

1. 更快的培訓速度和更高的效率
2. 低記憶體使用
3. 較好精度
4. 並行GPU學習支援
5. 能夠處理大規模資料

該框架是一種基於決策樹演算法的快速高效的梯度提升框架，用於排序、分類等機器學習任務。它是在微軟的分散式機器學習工具包專案下開發的。

由於LightGBM是基於決策樹演算法的，所以它以最佳擬合度按葉片狀分割樹，而其他增強演算法按層次或深度方向而不是按葉片狀分割樹。因此，在lightGBM中，當在同一片葉子上生長時，leaf-wise演算法能夠比level-wise 演算法減少更多的損耗，從而產生比現有任何提升演算法都難以達到的更好的精度。

此外，它是非常快的，所以有“light”這個詞。

參閱本文了解更多關於LightGBM的資訊：https://www..ticsvidhya.com/blog/2017/06/.-.-.-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 擴充套件包，這是實現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的內容：HTTPS://www-DistaSvIDHYA.COM/BLG/2017/08/CATBUSTOST-Autoto分類-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)

小結