先马后看！详解线性回归、朴素贝叶斯、随机森林在R和Python中的实现应用！（附代码）
来源| analyticsvidhya
编译| 火火酱，责编| Carol
出品 | AI科技大本营（ID：rgznai100）
谷歌的自动驾驶汽车和机器人得到了媒体的广泛关注，但是公司真正的未来是在机器学习领域，这一技术会使计算机变得更加智能、更个性化。——谷歌董事长埃里克·施密特（Eric Schmidt）
我们或许生活在一个人类历史上最具决定性的时期：从大型计算机到个人电脑，再到云计算时代。重要的不是过去已经发生了什么，而是未来将会发生什么。
数据科学导论：
https://courses.analyticsvidhya.com/courses/introduction-to-data-science-2/?utm_source=blog&utm_medium=essentialMLalgorithmsarticle
认证计划：面向数据科学初学者：
https://courses.analyticsvidhya.com/bundles/data-science-beginners-with-interview
本文主要围绕常用的机器学习算法：算法覆盖——线性回归、逻辑回归、朴素贝叶斯（Naive Bayes）、kNN、随即森林，等等。主要学习在R语言和Python中这些算法的理论和实现应用。
谁能从这篇指南中获益最多？
本文要讲的内容，可能是作者写过的最有价值的指南了。
写这篇指南的主要目的是帮助世界上那些有抱负的数据科学家和机器学习爱好者们简化他们的学习旅程。
本指南会帮助你解决机器学习问题，并获得一些实践经验。我将提供对于多个机器学习算法的高水平理解，以及运行这些算法的 R语言代码和Python代码。这些应该足够让你亲自动手试一试了。
我特地跳过了这些技术背后的统计数据，因为一开始你还不需要了解这些东西。因此，如果你想要从统计数据层面理解这些算法的话，那你可以去别的地方找找。但是，如果你想要为构建机器学习项目做好准备的话，那你应该会收获颇丰。
广义上来说，有3种机器学习算法
1. 监督式学习（Supervised Learning）
工作机制：该算法由一个目标/结果变量（或因变量）组成，该变量由已知的一系列预测变量（自变量）计算而来。利用这一系列变量，我们生成一个将输入值映射到所需输出值的函数。该训练过程会持续进行，直到模型在训练数据上达到预期精确度。监督式学习的例子有：回归（Regression）、决策树（Decision Tree）、随机森林（Random Forest）、K最近邻（KNN）、逻辑回归（Logistic Regression）等等。
决策树：
https://www.analyticsvidhya.com/blog/2015/01/decision-tree-simplified/）
随机森林：
https://www.analyticsvidhya.com/blog/2014/06/introduction-random-forest-simplified/）
2. 非监督式学习（Unsupervised Learning）
工作机制：在该算法中，我们不预测或估计任何目标变量或结果变量。此算法用于不同组内的聚类分析，被广泛用于对不同群体的客户进行细分，从而进行特定的干预。非监督式学习的例子有：Apriori算法、K–均值算法。
3. 强化学习（Reinforcement Learning）
工作机制：该算法能够训练机器进行决策。其工作原理为：让机器处于一个能够通过反复试错来训练自己的环境中。机器从过去的经验中进行学习，并试图通过学习最合适的知识来作出精准的商业判断。强化学习的例子有：马尔可夫决策过程（Markov Decision Process）。
常见机器学习算法列表
下面是一些常用的机器学习算法。这些算法几乎可以应用于所有数据问题：
1. 线性回归（Linear Regression）
2. 逻辑回归（Logistic Regression）
3. 决策树（Decision Tree）
4. SVM
5. 朴素贝叶斯（Naive Bayes）
6. K最近邻（kNN）
7. K均值算法（K-Means）
8. 随机森林（Random Forest）
9. 降维算法（Dimensionality Reduction Algorithms）
10. 梯度提升算法（Gradient Boosting algorithms）
[1] GBM
[2] XGBoost
[3] LightGBM
[4] CatBoost
1. 线性回归（Linear Regression）
线性回归常用于根据连续变量估计实际数值（房屋成本、电话呼叫次数、总销售额等）。在此，我们通过拟合一条最佳直线来建立自变量和因变量之间的关系。这条最佳拟合直线被称为回归线，用线性方程Y= a *X + b 来表示。
回顾童年经历能帮你更好地理解线性回归。假设让一个五年级的孩子在不问对方体重的情况下，将班上的同学按体重从轻到重进行排序，你觉得他（她）会怎么做？他（她）很可能会观察同学们的身高和体型，通过综合这些可见的参数来进行排序。这就是线性回归在实际生活中应用的例子。这个孩子实际上已经发现了身高、体型与体重之间有一定的关系，此关系类似于上面的等式。
在这个等式中：
· Y – 因变量
· a – 斜率
· X – 自变量
· b – 截距
系数a、b是通过最小化数据点与回归线之间距离的平方差之和而得到的。
在下面这个例子中，我们确定了最佳拟合线 y=0.2811x+13.9。已知人的身高，我们可以通过这个方程来求出其体重。
线性回归主要有一元线性回归和多元线性回归两种。一元线性回归的特点是只有一个自变量。多元线性回归的特点，顾名思义，存在多个自变量。在寻找最佳拟合直线时，可以拟合到多项或曲线回归。这就被称为多项或曲线回归。
现在，你可以试着通过以下链接中的编码窗口用Python来构建自己的线性回归模型了：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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 function）。因为它预测的是概率，所以其输出值（和预期一样）位于0 和 1 之间。
逻辑回归：
https://en.wikipedia.org/wiki/Logistic_function
让我们再次通过一个简单的例子来理解以下这个算法。
如果你的朋友给你出了一道难题。只有两种结果：要么你解开了，要么没解开。现在想象一下，假设你需要解答很多道题来找出你所擅长的主题，那么该研究的结果会像是这样：如果题目是一道十年级的三角函数题，那么你有 70%的可能会解开这道题。然而，如果题目是一道五年级的历史题，你只有30%的可能性会回答正确。这就是逻辑回归能提供给你的。
从数学上看，结果中机率的对数使用的是预测变量的线性组合模型。
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrenceln(odds) = ln(p/(1-p))logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXkp是兴趣特征出现的概率。它选择了使观察样本值的可能性最大化的值作为参数，而没有（像一般的回归分析用到的一样）选使误差平方和最小化的值。
现在，你或许要问，为什么要求出对数呢？简而言之，这种方法是复制阶梯函数的最佳数学方法之一。我也可以讲得更详细一些，但那就违背本篇指南的主旨了。
请在以下链接中用Python构建自己的逻辑回归模型并检查其准确性：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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）
这是我最喜欢也是使用最频繁的算法之一。该监督式学习算法常被用于分类问题。它，出人意料地，同时适用于分类因变量和连续因变量。在这个算法中，我们将总体分为两个或更多的同类群。基于最重要的属性/自变量来分成尽可能不同的组别。
要想了解更多相关信息，你可以阅读以下文章：
Decision Tree Simplified 简化决策树
图源: statsexchange
如上图所示，根据多个属性，人群被分为四个不同的小组，从而确定他们“会不会去玩”。为了将总人群分成不同的组别，需要用到很多技术，如基尼系数（Gini）、信息增益（Information Gain）、卡方（Chi-square）、熵（entropy）。
了解决策树工作机制的最好方式是玩Jezzball，这是一款来自于微软的经典游戏（见下图）。游戏的玩法是：在一个可以移动墙壁的房间里，你需要通过创建墙壁来分割出没有小球的最大空间。
因此，当你每次用墙壁来分隔房间时，都是试图在同一间房里创建两个不同的部分。决策树以非常相似的机制工作，即把总体尽可能地分割到不同的组里去。
更多信息参见: Simplified Version of Decision Tree Algorithms 决策树算法简化版
下面亲自动手用Python编写自己的决策树吧：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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 支持向量机（Support Vector Machine）
SVM是一种分类方法。在此算法中，我们将每个数据绘制为N维空间中的一个点（其中N是你所有的特征总数），每个特征的值对应一个坐标值。
例如，假设我们只有身高和头发长度两个特征，那么我们就在二维空间中标出这两个变量，其中每个点都有两个坐标，这些坐标被称为支持向量（Support Vectors）。
现在，我们要找到一些能够将两组不同数据分开的直线。找到符合要求的最优线：两个分组中距离该线最近的点到这条线的距离最远。
上图中，中间黑线将所有数据分为两组，两组中距离线最近的点（图中A、B点）到达黑线的距离满足最优条件（距离该线最远）。因此，这条直线就是我们的分类器。接下来，只要测试数据落到直线的哪一边，就将其分为哪一类。
更多信息参见: Simplified Version of Support Vector Machine支持向量机的简化
将这个算法想像成是在N维空间里玩JezzBall游戏，那么要调整的是：
· 现在你可以以任意角度画线/平面（而不是像经典游戏中那样只能在水平或者竖直方向画线）。
· 游戏的目的变成了把不同颜色的球分割在不同的空间里。
· 球的位置不会改变。
现在试着动手在以下窗口中用Python来设计一个SVM模型吧：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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) 是可能性，即已知类的前提下，预测变量的概率
· P(x) 是预测变量的先验概率
例子：让我们用一个例子来理解一下这个概念。下面有一个天气的训练数据集和对应的目标变量“玩”。现在，我们需要根据天气情况，将“玩”和“不玩”的参与者进行分类。我们可以按照以下步骤来执行：
第1步：把数据集转换成频率表。
第2步：利用概率（如当Overcast可能性=0.29时，玩耍的可能性为0.64），创建Likelihood表格。
第3步：现在，使用朴素贝叶斯方程来计算每一类的后验概率。后验概率最高的一类就是预测结果。
问题：如果天气晴朗，参与者就能玩。该陈述正确吗？
这个问题可以用上面讨论的方法求解，所以 P（玩 | 晴朗）= P（晴朗 | 玩）* P（玩）/ P （晴朗）
我们有 P （晴朗 |玩）= 3/9 = 0.33，P（晴朗） = 5/14 = 0.36, P（玩）= 9/14 = 0.64
现在，P(玩 | 晴朗）= 0.33 * 0.64 / 0.36 = 0.60，这可能性更大。
朴素贝叶斯使用相似的方法来预测不同属性的不同类的概率。该算法多用于文本分类，和涉及多个类的问题。
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- Nearest Neighbors)
kNN算法可用于分类和回归问题。然而，K–最近邻算法更常用于行业中的分类问题。K–最近邻算法是一个简单的算法，它存储所有可用的案例，并通过k个案例中的大多数情况给新案例分类。根据一个距离函数，新案例会被分配到通过距离函数测得的K个近邻中最常见的类中去。
这些距离函数可以是欧几里得距离（Euclidean）、曼哈顿距离（Manhattan）、闵可夫斯基距离（Minkowski）和汉明距离（Hamming）。前三个函数用于连续函数，第四个函数（汉明）被用于分类变量。如果 K=1，则该案例就直接被分配给离它最近的案例的类。有时，执行KNN建模时，选择 K 的大小确实是一个挑战。
我们的现实生活中常常会应用到KNN。如果你想要了解一个陌生人，你或许会想去找他的好朋友或所处的圈子来获取信息。
选择kNN前需要考虑的事情：
· KNN的计算成本很高。
· 变量应该统一化，否则范围较大的变量可能会造成偏差。
· 在进行kNN处理之前，要在处理阶段的离群点、噪音去除等方面多下功夫。
Python 代码：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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均值算法（K-Means）
这是一种能解决聚类问题的非监督式学习算法。其过程简单易行，将给定数据分类到一定数量的集群中去（假设有 k 个集群）。一个集群内的数据点对于对等集群来说是同质，且异构的。
还记得从墨迹中找出形状的方法吗？从某种程度上来说，K-均值算法与此有点类似。观察形状及延伸方式来辨认有多少种集群。
K-均值怎样形成集群：
1. K-均值为每个集群选择k个点，称为质心（centroid）。
2. 每个数据点与最近的质心形成一个集群，即k个集群。
3. 根据现有的集群成员查找每个集群的质心，然后就有了新的质心。
4. 当有了新的质心后，重复步骤2和3。找到每个数据点距离新质心的最近距离，然后与新的k-集群相关联。重复这个过程直至汇聚，即质心不再改变。
如何确定K值：
在K–均值算法中，我们有集群，每个集群有自己的质心。一个集群内的质心和各数据点之间距离的平方和形成了这个集群的平方值之和。此外，当所有集群的平方值之和相加，就组成了集群方案的平方值之和。
我们知道，随着集群数量的增加，K值会不断下降。但是，如果将结果绘制成图表，就会发现距离的平方和在急剧减少。到达某一K值后，减少的速度会大幅放缓。我们可以在此找到集群数量的最优值。
Python 代码：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
R 语言代码：
library(cluster)
fit <- kmeans(X, 3) # 5 cluster solution8. 随机森林（Random Forest）
随机森林是决策树的总体专有名词。在随机森林算法中，我们有一系列决策树（因此，被称为“森林”）。为了根据属性将新对象进行分类，每一棵决策树都给出一个分类，称之为该决策树为该分类“投票”。森林选择（在所有树中）获得票数最多的分类。
每棵树的种植&培育过程：
1. 假设训练集中的案例数为N，则使用重置抽样法在N个案例中随机抽取样本。该样本将作为此树生长的训练集。
2. 假设有M个输入变量，则定义数字m<<M。m表示从M中随机选择m个变量，该m中最好的切分将被用来切分该节点。M值在森林生长过程中保持不变。
3. 每棵树都尽可能地生长，不进行任何修剪。
如果你想了解更多关于此算法的详细信息，比较决策树和优化模型参数，可以阅读以下文章：
1. Introduction to Random forest – Simplified 随机森林简介-简化版
2. Comparing a CART model to Random Forest (Part 1) 比较CART模型与随机森林（上）
3. Comparing a Random Forest to a CART model (Part 2) 比较随机森林与CART模型（下）
4. Tuning the parameters of your Random Forest model 调节随机森林模型参数
Python代码：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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. 降维算法（Dimensionality Reduction Algorithms）
在过去的4-5年里，在很多阶段，信息都呈指数级增长。企业/政府机构/研究组织不仅带来了新资源，还捕捉着详尽的数据。
例如，电子商务公司正在获取更为详细的顾客的资料：人口统计信息、网页浏览记录、个人喜恶、购买记录、反馈，以及其他多种信息，比你附近杂货店的售货员更加关注你。
作为数据科学家，我们提供的数据也包含许多特点，听起来很适合构建良好且健壮的模型，但仍存在挑战：如何从 1000 或者 2000 个变量中里识别出最重要的变量呢？在这种情况下，降维算法和其他各算法（如决策树、随机森林、PCA、因子分析、给予相关矩阵的识别、缺失值比等）能够一起为我们提供帮助。
要想了解有关此算法的更多信息，可以阅读“Beginners Guide To Learn Dimension Reduction Techniques 降维技术初学者指南”。
Python 代码：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
R 语言代码：
library(stats)
pca <- princomp(train, cor = TRUE)
train_reduced <- predict(pca,train)
test_reduced <- predict(pca,test)10. 梯度提升算法（Gradient Boosting Algorithms）
10.1. GBM
当我们要利用大量数据进行有高预测力的预测时，会使用到GBM这种提升算法。提升算法（boosting）是多种学习算法的集成，它结合了建立在多个基础估计值基础上的预测结果，从而提高单一估计值的可靠性。这些提升算法通常在Kaggl、AV Hackathon、CrowdAnalytix等数据科学比赛中表现出色。
更多信息详见: Know about Boosting algorithms in detail 详细了解提升算法
Python 代码：
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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. XGBoost
这在某些Kaggle竞赛中，决定胜负的另一种经典梯度提升算法。
XGBoost具有极高的预测能力，这使其成为预测事件准确性的最佳选择。它同时具有线性模型和树学习算法的优点，这使得该算法比现有的梯度提升技术快了近10倍。
此算法支持包括回归、分类和排序在内的多种目标函数。
有关XGBoost的最有趣的事情之一是，它也被称为正则化增强技术（regularized boosting technique）。这有助于减少模型过拟合，并为Scala、Java、R、Python、Julia 和C++等语言提供了大量支持。
算法支持在GCE、AWS、Azure 和Yarn clusters等许多计算机上进行训练。
想要了解更多关于XGBoost和参数调整的信息，可以访问：
https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/
Python 代码:
https://id.analyticsvidhya.com/auth/login/?next=https://www.analyticsvidhya.com/blog/2017/09/common-machine-learning-algorithms/?&utm_source=coding-window-blog&source=coding-window-blog
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
训练速度更快且效率更高
降低内存使用量
精准度更高
支持并行和GPU学习
能够处理大规模数据
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最近发布的一款开源机器学习算法。它可以轻松地与深度学习框架（如Google的TensorFlow和Apple的Core ML）集成。
CatBoost最大的优点在于，它不需要像其他ML模型那样进行大量的数据训练，并且可以处理多种数据格式，不会破坏其稳健性。
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)结语
至此，我敢肯定你已经对常用的机器学习算法有了一定的了解了。作者写这篇文章并提供相应的R语言代码和Python代码的唯一目的就是帮助你找到起点。如果你想要完全掌握机器学习算法的话，那就马上开始吧。着手解决问题，加深对过程的理解，将这些代码用起来并从中发现乐趣！
这篇文章对你来说有帮助吗？请在下面评论区分享你的观点和想法。
【end】
◆
精彩推荐
◆
10+位来自华为、阿里、微软、CODING等名企的专家大牛为大家做全天直播！
在线答疑、吐槽评论、现场抽奖等与大咖多维互动，不出家门，用程序员的方式来共同“抗”疫！
扫码或者点击阅读原文，限时免费报名。
推荐阅读
你点的每个“在看”，我都认真当成了AI