阅读本文需要 15 分钟
谷歌的自动驾驶汽车和机器人研发之路受到很多阻碍，但该公司真正的未来是机器学习，这种技术使计算机变得更加智能和个性化。
– Eric Schmidt (谷歌主席)
我们可能生活在人类历史上最具决定性的时期。计算机正从大型主机过渡到 PC 再过渡到云计算。但它的定义不是发生了什么，而是未来几年将要发生什么。
对于像我这样的人来说，这一时期最令人兴奋的是工具和技术的*化，随之而来的是计算机的发展。今天，作为一名数据科学家，我能在几个小时内通过使用复杂算法来构建一个数据压缩模型。但是，取得这样的成绩并不容易！我经历了很多的辛苦！
谁会从这篇指南中受益？
我今天写得这篇指南可能是我写过的最有价值的一篇。
写这份指南背后的目的是为数据科学家和机器学习爱好者提供一些便利。通过这个指南，我相信你能够更好地处理机器学习问题并从中积累经验。我对各种机器学习算法都提供了相应的 Python & R 代码。这些应该足以让你大展身手了。
我会故意跳过这些技术背后的统计学知识，因为你不需要一开始就理解它们。所以，如果你想深入了解这些算法的理论知识，可以查看其它资料。但是，如果你想开始构建机器学习项目，那么这值得一试。
一般来说，机器学习算法分为三种类型。
1. 监督式学习
工作原理：该算法由一个目标/结果变量（或因变量）组成，该变量（或因变量）由给定的一组预测器（自变量）进行预测得到。使用这些变量集，我们可以生成输入映射到期望输出的函数。通过训练算法模型，让模型在训练数据上得到期望的准确度。监督学习的例子包括：回归、决策树、随机森林、KNN、Logistic 回归等。
2. 非监督式学习
工作原理：该算法没有任何目标/结果变量（或因变量）来预测或估计。它用于对样本中的不同类别进行聚类，广泛用于在不知道标签的情况下对不同群体进行划分。无监督学习的例子包括：Apriori 算法，k-均值。
3. 增强学习
工作原理：机器被训练来做出特定的决定。它是这样工作的：机器通过反复试验不断训练自己，从过去的经验中学习，并试图运用最好的知识，作出准确的决策。强化学习的例子包括：马尔可夫（Markov）决策过程。
常用的机器学习算法列表
下面列举了常用的机器学习算法。这些算法可以应用于所有的数据问题：
1. 线性回归
2. 逻辑回归
3. 决策树
4. SVM
5. 朴素贝叶斯
6. k 近邻
7. k-聚类
8. 随机森林
9. 降维算法
10. 梯度提升算法
1. GBM
2. XGBoost
3. LightGBM
4. 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）是主要用于分类问题的监督式学习算法。令人惊喜的是，它因变量可以是离散的也可以是连续的。在该算法中，我们将数据划分成两个或更多的组。划分的准则是基于最重要的属性/自变量，尽可能让不同组别之间的差别大一些。有关更多细节，您可以阅读：决策树简化教程：
https://www.analyticsvidhya.com/blog/2016/04/complete-tutorial-tree-based-modeling-scratch-in-python/
在上面这张图中，你可以看到，根据多个属性，样本（总的人数）最终被划分为四个不同的组，以标识 Play 或者 Don't Play。实现不同分组的方法有很多，例如 Gini、信息增益、卡方、熵。
了解决策树是如何运作的最好方法是玩 Jezzball —— 一个经典的微软游戏（下图）。基本上，你有一个房间有移动的墙壁，你需要创建墙壁，以便最大面积得到清除的球。
所以，每次你用墙拆开房间时，试图在同一个房间里创造 2 个不同的组别。这与决策树的工作原理非常类似。
更多决策树的知识请查阅：
https://www.analyticsvidhya.com/blog/2016/04/complete-tutorial-tree-based-modeling-scratch-in-python/
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(criterinotallow='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-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_compnotallow=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 树分类器，两种算法的区别请参阅：
https://discuss.analyticsvidhya.com/t/what-is-the-fundamental-difference-between-randomforest-and-gradient-boosting-algorithms/2341
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 参数调整的更多信息请参阅：
https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-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 是一种基于树的学习算法的梯度提升框架。它被设计成分布式和高效的，具有以下优点：
- 更快的训练速度和更高的效率
- 占用内存少
- 准确率高
- 并行 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(iteratinotallow=50, depth=3, learning_rate=0.1, loss_functinotallow='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 代码希望能帮助你快速上手。如果你热衷于掌握机器学习，请马上开始吧。带着问题，解释并应用这些代码，你会发现无穷的乐趣！
