机器学习算法精要

机器学习算法精要 | TinTin

广义而言，机器学习算法分三类

1.监督学习

工作原理：算法从一组给定的预测因子（独立变量）来预测目标/结果变量（或因变量），使用这些变量集生成映射输入到期望输出的函数，不断训练直到模型达到训练数据所需的精度水平。常见算法有：回归（Regression）、决策树（Decision Tree）、随机森林（Random Forest）、KNN、逻辑回归（Logistic Regression）等。

2.无监督学习

工作原理：算法中没有任何目标或结果变量要预测/估计，而是用于不同群体的种群聚集，广泛应用于不同群体的细分。常见算法有：关联规则算法（Apriori algorithm）、K-means。

3.增强学习

工作原理：算法中，机器被训练来做出特定的决定，通过反复试验不断训练机器，机器从过去的经验中学习，捕捉最好的知识以做出准确的决策。常见算法有：马尔科夫决策过程(Markov Decision Process)。

常用机器学习算法

1.线性回归 - Linear Regression
2.逻辑回归 - Logistic Regression
3.决策树 - Decision Tree
4.支持向量机 - SVM
5.朴素贝叶斯 - Naive Bayes
6.邻近算法 - kNN
7.K均值 - K-Means
8.随机森林 - Random Forest
9.降维算法 - Dimensionality Reduction Algorithms
10.梯度提升算法 - Gradient Boosting algorithms （GBM、XGBoost、LightGBM、CatBoost）

一、线性回归（Linear Regression）

线性回归是用连续变量来估计实际值（房屋成本、通话次数、总销售额等）,通过拟合一条最佳的线来建立自变量和因变量之间的关系，这个最佳拟合线称为回归线，用线性方程y = a*x + b表示。
了解线性回归的最好方法是重温童年的经历。要求一个第五年级的孩子通过体重的递增顺序来给他班上的学生排队，在不给出他们的体重的情况下，你认为这个孩子会怎么做？他（她）可能会观察他们的身高和身材（视觉分析），并综合这些可见参数给他们排队。这就是现实生活中的线性回归！这个孩子实际上已经知道身高和身材与体重的关系是由一种像上面的等式关系决定的。
等式中，y为因变量，x为自变量，a为斜率，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)

二、逻辑回归（Logistic Regression）

不要被它的名字混淆！它是一种分类而不是回归算法。它是用来估计基于给定自变量集的离散值（二进制值，如0/1，是/否，真/假）。简单地说，它通过将数据拟合到对数函数来预测事件发生的概率，因此，它也被称为对数回归。由于它预测了概率，其输出值介于0和1之间。
再一次通过一个简单的例子来理解一下。
假设你的朋友给你一个难题来解决，只有2种结果：解决、没解决。现在想象一下，机器通过给你做各种各样的测试来试图了解你擅长的科目，学习的结果将是这样的：如果给你一个十年级的三重测量问题，你有70%的概率来解决这个问题。另一方面，如果是五年级的历史问题，你只有30%的概率来解决这个问题。
在数学中，结果的对数几率（log odds：对数几率odds是体现阳性和阴性差异的这么一个指标）被模拟成预测变量的线性组合。

odds = p/ (1-p) 【事件发生可能性 / 事件发生可能性】

ln(odds) = ln(p/(1-p))

logit(p) = ln(p/(1-p)) = b0 + b1X1 + b2X2 + b3X3 + ... + bkXk

如上，P是存在目标特征的概率，它选择观察样本值的最大似然参数，而不选择普通回归中最小平方误差和。
现在，你可能会问，为什么要选择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)

除此之外，为了改进模型，还可以尝试更多不同的步骤：包括交互项、去除特征、正则化、使用非线性模型。

三、决策树（Decision Tree）

决策树是一种主要用于分类问题的监督学习算法，它适用于分类和连续因变量。在该算法中，我们将种群分成两个或更多的同质集，采用关键属性/自变量来尽可能区分的不同组。

在上图中，你可以看到，基于多个属性，种群被划分为四个不同的组，以确定“他们是否会玩”，采用Gini、信息增益、Chi平方、熵等多种算法将种群划分为不同的异质集。
了解决策树是如何运作的最好方法是玩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)

四、SVM (Support Vector Machine)

SVM是一种分类方法。在该算法中，我们将每个数据项绘制为n维空间中的一个点（其中n是具有的特征数），其中每个特征的值是特定坐标的值。
例如，若我们只有两个特征，身高和头发长度，我们首先在二维空间中绘制这两个变量，其中每个点有两个坐标（这些坐标被称为支持向量）。

现在，我们将找到一条分割两个不同分类数据集之间的数据的线，这是一条直线，使得两组中最靠近的点的距离最远。

在上面的例子中，将数据分割成两个不同的类的线是黑线，因为这两个最靠近的点离直线最远，这条线就是我们的分类器。这样，看测试数据落在该线的哪一边，就可将新数据分为什么类。
了解更多：支持向量机的简化版本
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)

五、朴素贝叶斯

朴素贝叶斯是一种基于贝叶斯定理的分类算法，具有预测属性之间的独立性假设。简单地说，朴素贝叶斯分类器假定类中的特定特征的存在与任何其他特征的存在无关。例如，如果一个水果是红色的、圆的、直径约3英寸的，它可以被认为是一个苹果。即使这些特征彼此依赖或存在其他特征，朴素贝叶斯分类器也认为所有这些属性对“这种水果是苹果”贡献的概率是独立的。
朴素贝叶斯模型易于建立，特别适用于非常大的数据集。由于它简单，朴素贝叶斯甚至被认为优于其他高度复杂的分类方法。
贝叶斯定理为通过P(C)、P(X)和P(X|C)来计算后验概率p(C|x)提供了一种途径。请看下面的方程式：

其中，P(C|x)是给定（待测）属性的类（目标）的后验概率,P(C)是类的先验概率,P(x|c)是给定类情况下待测属性出现的概率,P(x)是待测属性的先验概率。
例：有一个包含天气和相应的目标变量“玩”的训练数据集，现在，我们需要根据天气情况来判断是否可以去玩。
按如下步骤执行：
第1步：将数据集转换为频率表
第2步：通过比如阴天的概率为0.29和去玩的概率为0.64来创建似然表。

第3步：使用朴素贝叶斯公式计算每个类的后验概率，具有最高后验概率的类就是预测结果。
问题：如果天气晴朗会去玩，这个说法正确吗？
我们可以用上面讨论的方法求解它，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)

六、kNN (k- Nearest Neighbors)

KNN可以用于分类和回归问题，而在工业上常用在分类问题上。K近邻算法是一种简单的算法，它存储了所有可用的样本，并通过其k领域的多数表决对新的样本进行分类。样本的分类是K近邻范围内所有点通过距离函数测量的多数共识。
这些距离函数可以是欧几里得（Euclidean）、曼哈顿（Manhattan）、闵可夫斯基（Minkowski）和汉明（Hamming）距离，前三个函数用于连续函数，第四个（Hamming）用于分类变量，如果k＝1，则将该情况简单地分给其最近邻的类。在进行KNN建模时，选择K值是最大的难点。

KNN可以很容易地映射到我们的真实生活中，如果你想了解一个人，你没有他/她的信息，你可能从他的亲密朋友和他的圈子获得他/她的信息。
选择KNN之前要考虑的事项：1.KNN运行较耗时；2.变量需归一化，否则较高的范围变量会对它产生偏差；3.在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)

七、K-Means

K-Means是一种解决聚类问题的无监督算法。它的过程遵循一种简单且容易的方式，通过一定数量的簇（给定k簇）对给定的数据集进行分类。集群内的数据点对于每组是同质的和异质的。
记得从墨迹中找出形状吗？K-Means就能做类似的活动，通过观察形状能够辨认出多少不同的簇/种群存在。

K-means如何形成集群：
1.K-means为每个集群挑选K个点，称为质心。
2.每个数据点形成具有最接近质心的簇，即K簇。
3.根据现有的群集成员查找每个簇的质心，以获得新的质心。
4.当有了新的质心时，重复第2步和第3步。从新的质心找到每个数据点最近的距离，并与新的K簇关联。重复这个过程直到收敛，即质心不变。
如何确定K值：
在K-means中有簇，且每个簇都有它自己的质心。簇中质心与数据点之间差的平方之和构成该簇的平方值之和，当所有簇的平方值之和被添加时，也就有了簇解的平方值总和。
我们知道，随着簇的数量增加，这个值持续减小，但若绘出结果图，会看到平方距离的总和急剧下降到某个值：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

八、随机森林

随机森林是一个包含多个决策树的分类器，它是决策树的集合（被称为“森林”）。为了根据属性对新对象进行分类，每个树都给出分类，并称树为该类“投票”，森林选择选票最多的分类（遍及森林中的所有树）。
树生成如下：
1.如果训练集中的样本数为N，则随机抽取N个样本，但有放回，这个样本便是生成树的训练集。
2.如果有M个输入变量，在每个节点处指定一个远小于M的数m，从M中随机选择m个变量，并这些m上的最佳分割用于分割节点。在森林生长过程中，m的值保持不变。
3.每棵树尽可能最大的生长，没有修剪。
关于该算法的更多细节，与决策树和调谐模型参数进行比较，我建议您阅读这些文章：
1.随机森林简介
2.CART模型与随机森林的比较（第1部分）
3.随机森林与CART模型的比较（第2部分）
4.调整随机森林模型的参数
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)

九、降维算法

在过去的4-5年中，数据捕获在每一个可能的阶段都呈指数增长。企业/政府机构/研究机构不仅不断地有新的资源出现，而且还要非常详细地捕捉数据。
比如电子商务公司正在捕捉更多关于客户的细节，如他们的人口数据、网络浏览历史、他们喜欢或不喜欢的东西、购买历史、反馈和其他许多信息，以比他们最近的杂货店店主更个性化地关注他们。
作为一个数据科学家，我们所提供的数据也包含许多特征，这对于建立良好的鲁棒模型很有帮助，但是存在一个挑战，如何从一两千的数据中找到较主要的变量？在这种情况下，降维算法有助于结合决策树、随机森林、PCA、因子分析、基于相关矩阵、缺失值比率等多种算法进行识别。
要知道更多关于这个算法，你可以阅读“学习降维算法初学者指南”。
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)

十、梯度提升算法

十点一、GBM

GBM是一种利用大量数据进行预测的Boosting算法（Boosting算法是一种用来提高弱分类算法准确度的方法），具有很高的预测能力。实际上，Boosting是学习算法的一种综合，它结合了多个基估计的预测，以提高单个估计器的鲁棒性。它将多个弱预测因子或平均预测因子组合成一个强预测因子。这些Boosting算法在Kaggle、AV Hakason、CrowdAnalytix等数据科学竞赛中有很好。
了解更多：详细了解Boosting算法
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]

梯度提升分类器和随机森林是两种不同的提升树分类器，两种算法间的差异。

十点二、XGBoost

另一种经典的梯度提升算法通常是一些Kaggle比赛中成败的决定性选择。
XGBoost具有非常高的预测能力，这使得它成为事件精度的最佳选择。因为它同时具有线性模型和树学习算法，使得该算法比现有的梯度提升算法快近10倍。
XGBoost支持包括各种目标函数，包括回归、分类和排序。
XGBoost最有趣的事情之一是它也被称为一种正则提升算法，它助于减少过拟合建模，并且对Scala、Java、R、Python、Julia和C++等多种语言有很好的支持。
支持分布式训练和广泛训练，包括GCE，AWS，Azure和Yarn-clusters等许多机器。XGBoosting还可以与Spark、Flink和其他云数据流系统集成，并在Boosting进程的每一次迭代中进行内置的交叉验证。
有关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)

十点三、LightGBM

LightGBM是一种使用基于树的学习算法的梯度提升框架。它被设计成分布式的、高效的，优点如下：
.更快的训练速度和更高的效率
.低内存
.高精度
.支持并行GPU学习
.能够处理大规模数据
该框架是一种基于决策树算法的快速和高性能的梯度提升算法，用于排序、分类和许多其他机器学习任务。它是在微软的分布式机器学习工具包项目下开发的。
由于LightGBM是一种基于决策树的算法，LightGBM使用leaf-wise的树生长策略，而很多其他boosting算法采用depth-wise和level-wise的树生长策略。因此，LightGBM中，当在同一片叶子上生长时，leaf-wise算法可以比level-wise算法减少更多的损失，从而得到更高的精度，这是任何现有的Boosting算法很少能实现的。与depth-wise和level-wise的树生长策略相比，leaf-wise策略可以收敛的更快。
此外，因为LightGBM算法速度非常快，因此用“Light”这个词。
参考文章了解更多关于LightGBM：点这里。
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)

十点四、Catboost

Catboost是最近从Yandex开源的机器学习算法，它可以很容易地与谷歌的TensorFlow和苹果的Core ML等深度学习框架相结合。
关于Catboost最好的部分是，它不像其他ML模型那样需要大量的数据训练，并且可以工作在各种数据格式上，而不破坏它的鲁棒性。
在执行之前，务必确保处理好缺失数据。
CATBooST可以自动处理分类变量而不显示类型的转换误差，这有助于您更好地调整模型，而不是去挑出微小的误差。
了解更多关于Catboost：从这篇文章。
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)

至止，你将对常用的机器学习算法有所了解。