转自：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)

小结