精华内容
下载资源
问答
  • 2022-04-07 15:47:34

    详解 CatBoost 原理

    集成学习的两大准则:基学习器的准确性和多样性。
    算法:串行的Boosting和并行的Bagging,前者通过错判训练样本重新赋权来重复训练,来提高基学习器的准确性,降低偏差!后者通过采样方法,训练出多样性的基学习器,降低方差

    1.catboost 的优缺点

    • 性能卓越:在性能方面可以匹敌任何先进的机器学习算法
    • 鲁棒性/强健性:它减少了对很多超参数调优的需求,并降低了过度拟合的机会,这也使得模型变得更加具有通用性
    • 易于使用:提供与 scikit 集成的 Python 接口,以及 R 和命令行界面
    • 实用:可以处理类别型、数值型特征
    • 可扩展:支持自定义损失函数
    • 支持类别型变量,无需对非数值型特征进行预处理
    • 快速、可扩展的GPU版本,可以用基于GPU的梯度提升算法实现来训练你的模型,支持多卡并行
    • 快速预测,即便应对延时非常苛刻的任务也能够快速高效部署模型

    CatBoost是一种基于对称决策树(oblivious trees)为基学习器实现的参数较少、支持类别型变量和高准确性的GBDT框架,主要解决的痛点是高效合理地处理类别型特征,这一点从它的名字中可以看出来,CatBoost是由Categorical和Boosting组成。此外,CatBoost还解决了梯度偏差(Gradient Bias)以及预测偏移(Prediction shift)的问题,从而减少过拟合的发生,进而提高算法的准确性和泛化能力。

    与XGBoost、LightGBM相比,CatBoost的创新点有:

    • 嵌入了自动将类别型特征处理为数值型特征的创新算法。首先对categorical features做一些统计,计算某个类别特征(category)出现的频率,之后加上超参数,生成新的数值型特征(numerical features)。
    • Catboost 还使用了组合类别特征,可以利用到特征之间的联系,这极大的丰富了特征维度。
    • 采用排序提升的方法对抗训练集中的噪声点,从而避免梯度估计的偏差,进而解决预测偏移的问题。
    • 采用了完全对称树作为基模型。
    • 采用一种新的算法计算 leaf-values 。

    2.CatBoost 的一些原理

    2.1.处理类别特征的方法

    对于类别特征,如果类别数目不多,可以使用onehot编码。否则,很容易造成维度爆炸。catboost 不提倡使用one-hot编码,它设计了一种基于预测目标统计值的方法可以将类别特征转化为数值特征。颇有均值编码的思想。

    CatBoost 使用一个更有效的策略,一方面可以减少过拟合,另一方面使用全部数据来训练。对数据集先随机排序,对于每个样本的该类别特征中的某个取值,转换为数值型时都是基于该样本之前的类别label value取均值,同时加入了优先级(先验值)的权重系数。

    假设 σ = ( σ 1 , σ 2 , ⋯   , σ n ) \sigma = (\sigma_1, \sigma_2, \cdots, \sigma_n) σ=(σ1,σ2,,σn) 是随机排列序列,则有

    x σ p , k = ∑ j = 1 p − 1 [ x σ j , k = x σ p , k ] ∗ Y σ j + α ∗ P ∑ j = 1 p − 1 [ x σ j , k = x σ p , k ] + α x_{\sigma_p, k}=\frac{\sum_{j=1}^{p-1}[x_{\sigma_j, k}=x_{\sigma_p, k}]*Y_{\sigma_j}+\alpha * P}{\sum_{j=1}^{p-1}[x_{\sigma_j, k}=x_{\sigma_p, k}] + \alpha} xσp,k=j=1p1[xσj,k=xσp,k]+αj=1p1[xσj,k=xσp,k]Yσj+αP

    [ ⋅ ] [\cdot] [] 代表指示函数, P 就代表先验,对应回归任务,计算标签的平均值作为先验值;对于二分任务,将正类的出现概率作为先验值。 α \alpha α 就代表优先级的权重系数,这个是为防止低频次的特征带来的影响所用的平滑操作,如果不使用这个操作的话, 当对于某一个特征只有一个样本的时候,其特征编码就为 1,会有过拟合的风险。

    这种方法称为 Ordered Target Statistics 数值编码方法。可以有效解决预测漂移的问题,关于预测漂移https://blog.csdn.net/qq_42003997/article/details/104400825

    2.2.基于贪心策略的特征交叉方法

    使用Ordered Target Statistics 方法将类别特征转化成为数值特征以后,会影响到特征交叉,因为数值特征无法有效地进行交叉。为了有效地利用特征交叉,CatBoost 在将类别特征转换为数值编码的同时,会自动生成 交叉特征。但如果让全部的类别特征之间都进行交叉,两两交叉,三三交叉,四四交叉,这个复杂度是指数级的,特征维度一定会爆炸。

    CatBoost使用一种贪心的策略来进行特征交叉。生成tree的第一次分裂,CatBoost不使用任何交叉特征。在后面的分裂中,CatBoost会使用生成tree所用到的全部原始特征和交叉特征 跟 数据集中的全部 类别特征进行交叉。

    使用参数“max_ctr_complexity”控制特征交叉的最大个数。

    2.3.避免预测偏移的 Ordered Boosting 方法。

    使用XGBoost或者LightGBM做模型时,我们可能经常会发现模型在训练集上拟合的很好,train_auc甚至达到了1.0, 但是在验证集上却差了很多, val_auc 可能只有0.7。这当然有可能是因为tree的数量太多了,或者是每棵tree的leaves太多了,总之模型太复杂了造成了过拟合。

    但也有一些XGBoost和LightGBM自身算法的缺陷因素。我们知道LightGBM在训练下一棵tree的时候,需要计算前面这些tree构成的加法模型在所有样本上的一阶梯度和二阶梯度(Loss对模型预测结果的导数),然后用这些梯度来决定下一棵树的结构和叶子节点取值。

    但是我们计算的这些一阶梯度和二阶梯度值是问题的。前面的这些tree都是在这些样本上训练的,现在我们又在这些样本上估计模型预测结果的一阶和二阶梯度。我们应该换一些新的样本才更合理。但是我们从哪里找这些新的样本呢?

    CatBoost 的作者故伎重演。先将样本随机打乱,然后每个样本只使用排序在它前面的样本来训练模型。用这样的模型来估计这个样本预测结果的一阶和二阶梯度。然后用这些梯度构建一棵tree的结构,最终tree的每个叶子节点的取值,是使用全体样本进行计算的。

    这就是Ordered Boosting的主要思想。可以有效地减少梯度估计的误差,缓解预测偏移。但是会增加较多的计算量,影响训练速度。

    在定义CatBoost模型时,我们可以用’boosting_type’这个参数来设置是使用Ordered Boosting 还是 LightGBM那样的 Plain Boosting。如果不显式设置,CatBoost会根据样本和特征数量自己决定。

    详细步骤

    构建一颗树有两个阶段:第一,选择树结构;第二,在树结构固定后计算叶节点的值。CatBoost在第二阶段采用传统的GBDT方法执行,而在第一阶段采用修正的方法—即梯度步长的无偏估计。

    F i F^i Fi 为前 i i i 棵树的结构模型(已建好),为了使 g i ( X k , Y k ) g^i(X_k, Y_k) gi(Xk,Yk) 是关于模型 F i F^i Fi的无偏梯度,需要在训练的时候不使用样本 k k k

    catboost的具体做法:样本集为$ \lbrace(X_k, Y_k)\rbrace^{n}_{k=1}$ 按随机序列 σ \sigma σ 排序,树的棵数为 I I I 。首先,对于样本 X k X_k Xk, 初始化模型 M k M_k Mk。其次对于每一棵树,遍历每一个样本,对前 k − 1 k-1 k1 个样本,依次计算 Loss 的梯度 g i g_i gi ;再次将前 k − 1 k-1 k1 个样本的 g i g_i gi X j ( j = 1 , ⋯   , k − 1 ) X_j (j=1, \cdots, k-1) Xj(j=1,,k1)来构建模型 M M M ;最后,对每一个样本 X k X_k Xk ,用 M M M 来修正初始化的 M k M_k Mk,这样就可以得到一个分隔的模型 M k M_k Mk (并且这个模型不需要这个样本用梯度估计来更新)。重复上述操作,就可以得到每一个样本 X X X 的分隔模型 M M M。由此可见,每一个 M k M_k Mk 都共享相同的树结构。

    img

    在CatBoost中,构建样本集的 s 个随机序列来增强算法的鲁棒性。用不同的序列来训练不同的模型,这将不会导致过拟合。

    2.4.使用对称二叉树作为基模型,有正则作用且预测极快

    XGBoost和LightGBM采用的基模型是普通的二叉树,但是CatBoost采用的是对称的二叉树。

    这种对树结构上的约束有一定的正则作用。更为重要的是,它可以让CatBoost模型的推断过程极快。

    对于CatBoost的tree的预测过程来说,每个特征的分裂都是独立的,不分先后顺序,多个样本可以一起预测。

    img

    3.catboost 加速计算

    3.1. 快速评分

    CatBoost使用对称树(oblivious trees)作为基预测器。在这类树中,相同的分割准则在树的整个一层上使用。这种树是平衡的,不太容易过拟合。梯度提升对称树被成功地用于各种学习任务中。在对称树中,每个叶子节点的索引可以被编码为长度等于树深度的二进制向量。这在CatBoost模型评估器中得到了广泛的应用:我们首先将所有浮点特征、统计信息和独热编码特征进行二值化,然后使用二进制特征来计算模型预测值。

    3.2.基于GPU实现快速训练

    密集的数值特征:对于任何GBDT算法而言,最大的难点之一就是搜索最佳分割。尤其是对于密集的数值特征数据集来说,该步骤是建立决策树时的主要计算负担。CatBoost使用oblivious 决策树作为基模型,并将特征离散化到固定数量的箱子中以减少内存使用。就GPU内存使用而言,CatBoost至少与LightGBM一样有效。主要改进之处就是利用了一种不依赖于原子操作的直方图计算方法。

    类别型特征:CatBoost实现了多种处理类别型特征的方法,并使用完美哈希来存储类别型特征的值,以减少内存使用。由于GPU内存的限制,在CPU RAM中存储按位压缩的完美哈希,以及要求的数据流、重叠计算和内存等操作。通过哈希来分组观察。在每个组中,我们需要计算一些统计量的前缀和。该统计量的计算使用分段扫描GPU图元实现。

    多GPU支持:CatBoost中的GPU实现可支持多个GPU。分布式树学习可以通过数据或特征进行并行化。CatBoost采用多个学习数据集排列的计算方案,在训练期间计算类别型特征的统计数据。

    4. catboost 缺点

    • 对于类别型特征的处理需要大量的内存和时间;
    • 不同随机数的设定对于模型预测结果有一定的影响;
    更多相关内容
  • catboost_insurance_churn_rate 此回购协议是对的补充,在该,我使用XGBoost和lightgbm训练了模型以预测样本保险客户的流失率。 在此仓库中,相同的数据集已用于训练具有Catboost的模型。 Catboost Catboost已与...
  • sudo pip3 install catboost-0.16.5-cp36-none-manylinux1_x86_64.whl
  • 提出通过综合学习粒子群算法(Comprehensive Learning Particle Swarm Optimization, CLPSO)优化CatBoost集成学习算法(CLPSO-CatBoost)的贷款风险预测方法, 该算法改善了全局搜索能力、避免了陷入容易陷入局部最优的...
  • CatBoost.pdf

    2020-04-29 19:55:32
    catboost原论文,方便自己使用,也同时方便大家的使用,其实网络上也很好找的,这个可能不是随时都方便的。如有侵权,联系删除。
  • 本文主要参考Battle of the Boosting Algos: LGB, XGB, Catboost,结果与原文有出入。 文章目录1. 对比标准1.1 数据集1.2 规则1.3 版本2. 结果2.1 准确率2.2 训练时间和预测时间2.3 可解释性2.3.1 特征重要性2.3.2 ...
  • 近几十年来,人们生活水平显著提高,...本文通过分析糖尿病的特点,针对医疗数据样本量小、容易缺失的特点,选择IV值分析进行特征选择、使用一种新型的Boosting算法CatBoost进行糖尿病患者预测,取得了显著的预测效果.
  • 清华镜像源安装 NGboost XGboost Catboost pip install catboost -i https://pypi.tuna.tsinghua.edu.cn/simple pip install ngboost -i https://pypi.tuna.tsinghua.edu.cn/simple pip install xgboost -i ...
  • CatBoost是一个快速,高性能的开放源代码库,可用于增强决策树的梯度。 这是一种具有大量应用程序的机器学习方法,包括针对Python,R,Java,C ++的排名,分类,回归和其他机器学习任务。 与许多数据集上的其他GBDT...
  • GBDT实现:XGBoost、LightGBM、Catboost对比 参考https://www.kaggle.com/lavanyashukla01/battle-of-the-boosting-algos-lgb-xgb-catboost
  • 灰狼优化算法(Grey Wolf Optimizer,GWO)由澳大利亚格里菲斯大学学者 Mirjalili 等人于2014年提出来的一种群智能优化算法。该算法受到了灰狼捕食猎物活动的启发...用GWO优化CatBoost的参数来进行物联网入侵检测分类。
  • Catboost-MNIST.ipynb

    2020-02-20 20:27:49
    MNIST & Catboost保存模型并预测 https://blog.csdn.net/lly1122334/article/details/104407869
  • 使用TensorFlow和CatBoost的野火和野火热点检测系统。 该程序首先使用图像分类(Keras CNN)来识别给定卫星图像中是否存在野火。 如果未检测到火灾,则应用程序将向国家海洋和大气管理局查询周围区域和给定时间的...
  • pip install catboost 数据集 分类:MNIST(60000条数据784个特征),已上传CSDN 代码 import random import numpy as np import pandas as pd import matplotlib.pyplot as plt from catboost import ...
  • catBoost 原稿

    2018-11-23 17:08:49
    文档是catBoost 原本,想要看看原算法的细节,请从原文开始
  • catboost介绍

    千次阅读 2021-09-05 15:50:30
    一、Catboost简介 全称:Gradient Boosting(梯度提升) + Categorical Features(类别型特征) 作者:俄罗斯的搜索巨头Yandex 官方地址 论文链接 | 项目地址  文档地址 视频 二、Catboost的特点  一般来说,...

    一、Catboost简介

    二、Catboost的特点

      一般来说,Gradient Boosting(GB)方法适用于异质化数据。即,若你的数据集全由图片数据构成或者全由视频数据构成之类的,我们称其为同质化数据,这时使用神经网络往往会有更好的表现。但对于异质化数据,比如说数据集中有user gender,user age,也有content data等等的情况,GB方法的表现往往更好。GB方法比神经网络的入门门槛更低,使用起来也更简单。

      NN和GB方法可以结合起来使用,并常常有很好的表现。我们可以使用NN方法学习embedding feature,并且和其他一些特征结合起来,再过GBDT。

      Catboost具有一些和其他类似的库不同的特征:

    1.类别型特征

      对于可取值的数量比独热最大量还要大的分类变量,CatBoost 使用了一个非常有效的编码方法,这种方法和均值编码类似,但可以降低过拟合情况。它的具体实现方法如下:

    • 将输入样本集随机排序,并生成多组随机排列的情况。
    • 将浮点型或属性值标记转化为整数。
    • 将所有的分类特征值结果都根据以下公式,转化为数值结果。

      其中 CountInClass 表示在当前分类特征值中,有多少样本的标记值是「1」;Prior 是分子的初始值,根据初始参数确定。TotalCount 是在所有样本中(包含当前样本),和当前样本具有相同的分类特征值的样本数量。可以用下面的数学公式表示:

    特征组合

    其次,它用特殊的方式处理categorical features。首先他们会计算一些数据的statistics。计算某个category出现的频率,加上超参数,生成新的numerical features。这一策略要求同一标签数据不能排列在一起(即先全是0之后全是1这种方式),训练之前需要打乱数据集。第二,使用数据的不同排列(实际上是4个)。在每一轮建立树之前,先扔一轮骰子,决定使用哪个排列来生成树。第三,考虑使用categorical features的不同组合。例如颜色和种类组合起来,可以构成类似于blue dog这样的feature。当需要组合的categorical features变多时,catboost只考虑一部分combinations。在选择第一个节点时,只考虑选择一个feature,例如A。在生成第二个节点时,考虑A和任意一个categorical feature的组合,选择其中最好的。就这样使用贪心算法生成combinations。第四,除非向gender这种维数很小的情况,不建议自己生成one-hot vectors,最好交给算法来处理。

    2.克服梯度偏差

    catboost和其他算法计算leaf-value的方法不同。传统的boosting使用平均数,但这个估计是有偏的,会导致过拟合。而Catboost则采用另外的计算方法。

      CatBoost,和所有标准梯度提升算法一样,都是通过构建新树来拟合当前模型的梯度。然而,所有经典的提升算法都存在由有偏的点态梯度估计引起的过拟合问题。许多利用GBDT技术的算法(例如,XGBoost、LightGBM),构建一棵树分为两个阶段:选择树结构和在树结构固定后计算叶子节点的值。为了选择最佳的树结构,算法通过枚举不同的分割,用这些分割构建树,对得到的叶子节点中计算值,然后对得到的树计算评分,最后选择最佳的分割。两个阶段叶子节点的值都是被当做梯度[8]或牛顿步长的近似值来计算。CatBoost第一阶段采用梯度步长的无偏估计,第二阶段使用传统的GBDT方案执行。

    3.快速评分

    Catboost使用对称树。XGboost一层一层地建立节点,lightGBM一个一个地建立节点,而Catboost总是使用完全二叉树。它的节点是镜像的。Catboost称对称树有利于避免overfit,增加可靠性,并且能大大加速预测等等。

      CatBoost使用oblivious树作为基本预测器,这种树是平衡的,不太容易过拟合。oblivious树中,每个叶子节点的索引可以被编码为长度等于树深度的二进制向量。CatBoost首先将所有浮点特征、统计信息和独热编码特征进行二值化,然后使用二进制特征来计算模型预测值。

    4.基于GPU实现快速学习

    • 密集的数值特征

      任何GBDT算法,对于密集的数值特征数据集来说,搜索最佳分割是建立决策树时的主要计算负担。CatBoost利用oblivious决策树作为基础模型,并将特征离散化到固定数量的箱子中以减少内存使用。就GPU内存使用而言,CatBoost至少与LightGBM一样有效。主要改进之处就是利用了一种不依赖于原子操作的直方图计算方法。

    • 类别型特征

      CatBoost使用完美哈希来存储类别特征的值,以减少内存使用。由于GPU内存的限制,在CPU RAM中存储按位压缩的完美哈希,以及要求的数据流、重叠计算和内存等操作。通过哈希来分组观察。在每个组中,我们需要计算一些统计量的前缀和。该统计量的计算使用分段扫描GPU图元实现。

    • 多GPU支持

      CatBoost中的GPU实现可支持多个GPU。分布式树学习可以通过数据或特征进行并行化。CatBoost采用多个学习数据集排列的计算方案,在训练期间计算分类特征的统计数据。

    三、与xgboost、lightgbm的对比

    参数对比:

    数据集:

    在这里,我使用了 2015 年航班延误的 Kaggle 数据集,其中同时包含分类变量和数值变量。这个数据集中一共有约 500 万条记录,因此很适合用来同时评估比较三种 boosting 算法的训练速度和准确度。我使用了 1% 的数据:5 万行记录。

    以下是建模使用的特征:

    月、日、星期:整型数据
    航线或航班号:整型数据
    出发、到达机场:数值数据
    出发时间:浮点数据
    到达延误情况:这个特征作为预测目标,并转为二值变量:航班是否延误超过 10 分钟
    距离和飞行时间:浮点数据

    import pandas as pd, numpy as np, time
    from sklearn.model_selection import train_test_split
    

    data = pd.read_csv(“flight-delays/flights.csv”)
    data = data.sample(frac = 0.1, random_state=10)#500->50

    data = data.sample(frac = 0.1, random_state=10)#50->5

    data.shape#(58191, 31)

    data = data[[“MONTH”,“DAY”,“DAY_OF_WEEK”,“AIRLINE”,“FLIGHT_NUMBER”,“DESTINATION_AIRPORT”,
    “ORIGIN_AIRPORT”,“AIR_TIME”, “DEPARTURE_TIME”,“DISTANCE”,“ARRIVAL_DELAY”]]
    data.dropna(inplace=True)

    data[“ARRIVAL_DELAY”] = (data[“ARRIVAL_DELAY”]>10)*1
    #data.head()

    cols = [“AIRLINE”,“FLIGHT_NUMBER”,“DESTINATION_AIRPORT”,“ORIGIN_AIRPORT”]
    for item in cols:
    data[item] = data[item].astype(“category”).cat.codes +1

    train, test, y_train, y_test = train_test_split(data.drop([“ARRIVAL_DELAY”], axis=1), data[“ARRIVAL_DELAY”],
    random_state=10, test_size=0.25)

     最终的数据集大概长这个样子:

    1.xgboost

      和 CatBoost 以及 LGBM 算法不同,XGBoost 本身无法处理分类变量,而是像随机森林一样,只接受数值数据。因此在将分类数据传入 XGBoost 之前,必须通过各种编码方式:例如标记编码、均值编码或独热编码对数据进行处理。

    import xgboost as xgb
    from sklearn.grid_search import GridSearchCV
    from sklearn import metrics
    

    def auc(m, train, test):
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
    metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

    Parameter Tuning
    model = xgb.XGBClassifier()
    param_dist = {“max_depth”: [10,30,50],
    “min_child_weight” : [1],
    “n_estimators”: [200],
    “learning_rate”: [0.16],}
    grid_search = GridSearchCV(model, param_grid=param_dist, cv = 3,
    verbose=10, n_jobs=-1)
    grid_search.fit(train, y_train)

    grid_search.best_estimator_

    model = xgb.XGBClassifier(max_depth=10, min_child_weight=1, n_estimators=200,
    n_jobs=-1 , verbose=1,learning_rate=0.16)

    train.shape,y_train.shape#((42855, 10), (42855,))

    model.fit(train,y_train)

    auc(model,train,test)#过拟合 (1.0, 0.6990888367179413)

      

    2.Light GBM

      和 CatBoost 类似,LighGBM 也可以通过使用特征名称的输入来处理属性数据;它没有对数据进行独热编码,因此速度比独热编码快得多。LGBM 使用了一个特殊的算法来确定属性特征的分割值。注意,在建立适用于 LGBM 的数据集之前,需要将分类变量转化为整型变量;此算法不允许将字符串数据传给分类变量参数。

    (1)不加categorical_feature 选项

    import lightgbm as lgb
    from sklearn import metrics
    

    def auc2(m, train, test):
    return (metrics.roc_auc_score(y_train,m.predict(train)),
    metrics.roc_auc_score(y_test,m.predict(test)))

    lg = lgb.LGBMClassifier(silent=False)
    param_dist = {“max_depth”: [25,50, 75],
    “learning_rate” : [0.01,0.05,0.1],
    “num_leaves”: [300,900,1200],
    “n_estimators”: [200]
    }
    grid_search = GridSearchCV(lg, n_jobs=-1, param_grid=param_dist, cv = 3, scoring=“roc_auc”, verbose=5)
    grid_search.fit(train,y_train)
    grid_search.best_estimator_

    d_train = lgb.Dataset(train, label=y_train)
    params = {“max_depth”: 50, “learning_rate” : 0.1, “num_leaves”: 900, “n_estimators”: 300}

    Without Categorical Features

    model2 = lgb.train(params, d_train)

    auc2(model2, train, test)#(1.0, 0.6813950368358092)

    (2)加categorical_feature 选项

    #With Catgeorical Features
    cate_features_name = ["MONTH","DAY","DAY_OF_WEEK","AIRLINE","DESTINATION_AIRPORT",
                     "ORIGIN_AIRPORT"]
    

    d_train = lgb.Dataset(train, label=y_train)

    model2 = lgb.train(params, d_train, categorical_feature = cate_features_name)

    auc2(model2, train, test)#(1.0, 0.6781812538027399)

      

    3. CatBoost

      在对 CatBoost 调参时,很难对分类特征赋予指标。因此,同时给出了不传递分类特征时的调参结果,并评估了两个模型:一个包含分类特征,另一个不包含。我单独调整了独热最大量,因为它并不会影响其他参数。

      如果未在cat_features参数中传递任何内容,CatBoost会将所有列视为数值变量。注意,如果某一列数据中包含字符串值,CatBoost 算法就会抛出错误。另外,带有默认值的 int 型变量也会默认被当成数值数据处理。在 CatBoost 中,必须对变量进行声明,才可以让算法将其作为分类变量处理。

    (1)不加Categorical features选项

    import catboost as cb
    cat_features_index = [0,1,2,3,4,5,6]
    

    def auc(m, train, test):
    return (metrics.roc_auc_score(y_train,m.predict_proba(train)[:,1]),
    metrics.roc_auc_score(y_test,m.predict_proba(test)[:,1]))

    params = {‘depth’: [4, 7, 10],
    ‘learning_rate’ : [0.03, 0.1, 0.15],
    ‘l2_leaf_reg’: [1,4,9],
    ‘iterations’: [300]}
    cb = cb.CatBoostClassifier()
    cb_model = GridSearchCV(cb, params, scoring=“roc_auc”, cv = 3)
    cb_model.fit(train, y_train)

    With Categorical features

    clf = cb.CatBoostClassifier(eval_metric=“AUC”, depth=10, iterations= 500, l2_leaf_reg= 9,
    learning_rate= 0.15)
    %timeit clf.fit(train,y_train)

    auc(clf, train, test)#(0.7994405189483305, 0.7097991233818941)

     (2)有Categorical features选项

    # With Categorical features
    clf = cb.CatBoostClassifier(eval_metric="AUC",one_hot_max_size=31, \
                                depth=10, iterations= 500, l2_leaf_reg= 9, learning_rate= 0.15)
    clf.fit(train,y_train, cat_features= cat_features_index)
    

    auc(clf, train, test)#(0.7937591249216596, 0.7167802198229718)

      


       请记住,CatBoost 在测试集上表现得最好,测试集的准确度最高(0.716)、过拟合程度最小(在训练集和测试集上的准确度很接近)以及最小的预测和调试时间。但这个表现仅仅在有分类特征,而且调节了独热最大量时才会出现。如果不利用 CatBoost 算法在这些特征上的优势,它的表现效果就会变成最差的:仅有 0.709 的准确度。因此我们认为,只有在数据中包含分类变量,同时我们适当地调节了这些变量时,CatBoost 才会表现很好。

      第二个使用的是 XGBoost,它的表现也相当不错。即使不考虑数据集包含有转换成数值变量之后能使用的分类变量,它的准确率也和 CatBoost 非常接近了。但是,XGBoost 唯一的问题是:它太慢了。尤其是对它进行调参,非常令人崩溃。更好的选择是分别调参,而不是使用 GridSearchCV。

      最后一个模型是 LightGBM,这里需要注意的一点是,在使用 CatBoost 特征时,LightGBM 在训练速度和准确度上的表现都非常差。我认为这是因为它在分类数据中使用了一些修正的均值编码方法,进而导致了过拟合(训练集准确率非常高:1.0,尤其是和测试集准确率相比之下)。但如果我们像使用 XGBoost 一样正常使用 LightGBM,它会比 XGBoost 更快地获得相似的准确度,如果不是更高的话(LGBM—0.681, XGBoost—0.699)。

      最后必须指出,这些结论在这个特定的数据集下成立,在其他数据集中,它们可能正确,也可能并不正确。但在大多数情况下,XGBoost 都比另外两个算法慢。

    四、优缺点

    优点:

    • 性能卓越:在性能方面可以匹敌任何先进的机器学习算法;
    • 鲁棒性/强健性:它减少了对很多超参数调优的需求,并降低了过度拟合的机会,这也使得模型变得更加具有通用性;
    • 易于使用:提供与scikit集成的Python接口,以及R和命令行界面;
    • 实用:可以处理类别型、数值型特征;可扩展:支持自定义损失函数




     

    参考文献:

    【1】从结构到性能,一文概述XGBoost、Light GBM和CatBoost的同与不同

    【2】CatBoost vs. Light GBM vs. XGBoost

    【3】Catboost学习笔记

    【4】机器学习算法之Catboost

    【5】github:https://github.com/catboost/catboost/tree/master/catboost/tutorials

    【6】Python3机器学习实践:集成学习之CatBoost

    展开全文
  • 深入理解CatBoost

    千次阅读 多人点赞 2020-02-11 15:18:09
    CatBoost是一种基于对称决策树(oblivious trees)为基学习器实现的参数较少、支持类别型变量和高准确性的GBDT框架,主要解决的痛点是高效合理地处理类别型特征,这一点从它的名字中可以看出来,CatBoost是由...

    本文主要内容概览:
    在这里插入图片描述

    1.CatBoost简介

    CatBoost是俄罗斯的搜索巨头Yandex在2017年开源的机器学习库,是Boosting族算法的一种。CatBoost和XGBoost、LightGBM并称为GBDT的三大主流神器,都是在GBDT算法框架下的一种改进实现。XGBoost被广泛的应用于工业界,LightGBM有效的提升了GBDT的计算效率,而Yandex的CatBoost号称是比XGBoost和LightGBM在算法准确率等方面表现更为优秀的算法。

    CatBoost是一种基于对称决策树(oblivious trees)为基学习器实现的参数较少、支持类别型变量和高准确性的GBDT框架,主要解决的痛点是高效合理地处理类别型特征,这一点从它的名字中可以看出来,CatBoost是由Categorical和Boosting组成。此外,CatBoost还解决了梯度偏差(Gradient Bias)以及预测偏移(Prediction shift)的问题,从而减少过拟合的发生,进而提高算法的准确性和泛化能力。

    与XGBoost、LightGBM相比,CatBoost的创新点有:

    • 嵌入了自动将类别型特征处理为数值型特征的创新算法。首先对categorical features做一些统计,计算某个类别特征(category)出现的频率,之后加上超参数,生成新的数值型特征(numerical features)。
    • Catboost还使用了组合类别特征,可以利用到特征之间的联系,这极大的丰富了特征维度。
    • 采用排序提升的方法对抗训练集中的噪声点,从而避免梯度估计的偏差,进而解决预测偏移的问题。
    • 采用了完全对称树作为基模型。

    2. 类别型特征

    2.1 类别型特征的相关工作

    所谓类别型特征,即这类特征不是数值型特征,而是离散的集合,比如省份名(山东、山西、河北等),城市名(北京、上海、深圳等),学历(本科、硕士、博士等)。在梯度提升算法中,最常用的是将这些类别型特征转为数值型来处理,一般类别型特征会转化为一个或多个数值型特征。

    如果某个类别型特征基数比较低(low-cardinality features),即该特征的所有值去重后构成的集合元素个数比较少,一般利用One-hot编码方法将特征转为数值型。One-hot编码可以在数据预处理时完成,也可以在模型训练的时候完成,从训练时间的角度,后一种方法的实现更为高效,CatBoost对于基数较低的类别型特征也是采用后一种实现。

    显然,在高基数类别型特征(high cardinality features) 当中,比如 user ID,这种编码方式会产生大量新的特征,造成维度灾难。一种折中的办法是可以将类别分组成有限个的群体再进行One-hot编码。一种常被使用的方法是根据目标变量统计(Target Statistics,以下简称TS)进行分组,目标变量统计用于估算每个类别的目标变量期望值。甚至有人直接用TS作为一个新的数值型变量来代替原来的类别型变量。重要的是,可以通过对TS数值型特征的阈值设置,基于对数损失、基尼系数或者均方差,得到一个对于训练集而言将类别一分为二的所有可能划分当中最优的那个。在LightGBM当中,类别型特征用每一步梯度提升时的梯度统计(Gradient Statistics,以下简称GS)来表示。虽然为建树提供了重要的信息,但是这种方法有以下两个缺点:

    • 增加计算时间,因为需要对每一个类别型特征,在迭代的每一步,都需要对GS进行计算;
    • 增加存储需求,对于一个类别型变量,需要存储每一次分离每个节点的类别;

    为了克服这些缺点,LightGBM以损失部分信息为代价将所有的长尾类别归为一类,作者声称这样处理高基数类别型特征时比One-hot编码还是好不少。不过如果采用TS特征,那么对于每个类别只需要计算和存储一个数字。

    因此,采用TS作为一个新的数值型特征是最有效、信息损失最小的处理类别型特征的方法。TS也被广泛应用在点击预测任务当中,这个场景当中的类别型特征有用户、地区、广告、广告发布者等。接下来我们着重讨论TS,暂时将One-hot编码和GS放一边。

    2.2 目标变量统计(Target Statistics)

    CatBoost算法的设计初衷是为了更好的处理GBDT特征中的categorical features。在处理 GBDT特征中的categorical features的时候,最简单的方法是用 categorical feature 对应的标签的平均值来替换。在决策树中,标签平均值将作为节点分裂的标准。这种方法被称为 Greedy Target-based Statistics , 简称 Greedy TS,用公式来表达就是:

    x ^ k i = ∑ j = 1 n [ x j , k = x i , k ] ⋅ Y i ∑ j = 1 n [ x j , k = x i , k ] \hat{x}_k^i=\frac{\sum_{j=1}^{n}[x_{j,k}=x_{i,k}]\cdot Y_i}{\sum_{j=1}^{n}[x_{j,k}=x_{i,k}]} \\ x^ki=j=1n[xj,k=xi,k]j=1n[xj,k=xi,k]Yi

    这种方法有一个显而易见的缺陷,就是通常特征比标签包含更多的信息,如果强行用标签的平均值来表示特征的话,当训练数据集和测试数据集数据结构和分布不一样的时候会出条件偏移问题。

    一个标准的改进 Greedy TS的方式是添加先验分布项,这样可以减少噪声和低频率类别型数据对于数据分布的影响:

    x ^ k i = ∑ j = 1 p − 1 [ x σ j , k = x σ p , k ] Y σ j + a ⋅ p ∑ j = 1 p − 1 [ x σ j , k = x σ p , k ] + a \hat{x}_k^i=\frac{\sum_{j=1}^{p-1}{[x_{\sigma_{j,k}}=x_{\sigma_{p,k}}]}Y_{\sigma_{j}}+a\cdot p}{\sum_{j=1}^{p-1}{[x_{\sigma_{j,k}}=x_{\sigma_{p,k}}]}+a} \\ x^ki=j=1p1[xσj,k=xσp,k]+aj=1p1[xσj,k=xσp,k]Yσj+ap

    其中 p p p 是添加的先验项, a a a 通常是大于 0 0 0 的权重系数。添加先验项是一个普遍做法,针对类别数较少的特征,它可以减少噪声数据。对于回归问题,一般情况下,先验项可取数据集label的均值。对于二分类,先验项是正例的先验概率。利用多个数据集排列也是有效的,但是,如果直接计算可能导致过拟合。CatBoost利用了一个比较新颖的计算叶子节点值的方法,这种方式(oblivious trees,对称树)可以避免多个数据集排列中直接计算会出现过拟合的问题。

    当然,在论文《CatBoost: unbiased boosting with categorical features》中,还提到了其它几种改进Greedy TS的方法,分别有:Holdout TS、Leave-one-out TS、Ordered TS。我这里就不再翻译论文中的这些方法了,感兴趣的同学可以自己翻看一下原论文。

    2.3 特征组合

    值得注意的是几个类别型特征的任意组合都可视为新的特征。例如,在音乐推荐应用中,我们有两个类别型特征:用户ID和音乐流派。如果有些用户更喜欢摇滚乐,将用户ID和音乐流派转换为数字特征时,根据上述这些信息就会丢失。结合这两个特征就可以解决这个问题,并且可以得到一个新的强大的特征。然而,组合的数量会随着数据集中类别型特征的数量成指数增长,因此不可能在算法中考虑所有组合。为当前树构造新的分割点时,CatBoost会采用贪婪的策略考虑组合。对于树的第一次分割,不考虑任何组合。对于下一个分割,CatBoost将当前树的所有组合、类别型特征与数据集中的所有类别型特征相结合,并将新的组合类别型特征动态地转换为数值型特征。CatBoost还通过以下方式生成数值型特征和类别型特征的组合:树中选定的所有分割点都被视为具有两个值的类别型特征,并像类别型特征一样被进行组合考虑。

    2.4 CatBoost处理Categorical features总结

    • 首先会计算一些数据的statistics。计算某个category出现的频率,加上超参数,生成新的numerical features。这一策略要求同一标签数据不能排列在一起(即先全是 0 0 0之后全是 1 1 1这种方式),训练之前需要打乱数据集。
    • 第二,使用数据的不同排列(实际上是 4 4 4个)。在每一轮建立树之前,先扔一轮骰子,决定使用哪个排列来生成树。
    • 第三,考虑使用categorical features的不同组合。例如颜色和种类组合起来,可以构成类似于blue dog这样的特征。当需要组合的categorical features变多时,CatBoost只考虑一部分combinations。在选择第一个节点时,只考虑选择一个特征,例如A。在生成第二个节点时,考虑A和任意一个categorical feature的组合,选择其中最好的。就这样使用贪心算法生成combinations。
    • 第四,除非向gender这种维数很小的情况,不建议自己生成One-hot编码向量,最好交给算法来处理。
      在这里插入图片描述

    3. 克服梯度偏差

    对于学习CatBoost克服梯度偏差的内容,我提出了三个问题:

    • 为什么会有梯度偏差?
    • 梯度偏差造成了什么问题?
    • 如何解决梯度偏差?

    CatBoost和所有标准梯度提升算法一样,都是通过构建新树来拟合当前模型的梯度。然而,所有经典的提升算法都存在由有偏的点态梯度估计引起的过拟合问题。在每个步骤中使用的梯度都使用当前模型中的相同的数据点来估计,这导致估计梯度在特征空间的任何域中的分布与该域中梯度的真实分布相比发生了偏移,从而导致过拟合。为了解决这个问题,CatBoost对经典的梯度提升算法进行了一些改进,简要介绍如下。

    许多利用GBDT技术的算法(例如,XGBoost、LightGBM),构建下一棵树分为两个阶段:选择树结构和在树结构固定后计算叶子节点的值。为了选择最佳的树结构,算法通过枚举不同的分割,用这些分割构建树,对得到的叶子节点计算值,然后对得到的树计算评分,最后选择最佳的分割。两个阶段叶子节点的值都是被当做梯度或牛顿步长的近似值来计算。在CatBoost中,第一阶段采用梯度步长的无偏估计,第二阶段使用传统的GBDT方案执行。既然原来的梯度估计是有偏的,那么怎么能改成无偏估计呢?

    F i F_{i} Fi 为构建 i i i 棵树后的模型, g i ( X k , Y k ) g^i(X_k,Y_k) gi(Xk,Yk) 为构建 i i i 棵树后第 k k k 个训练样本上面的梯度值。为了使得 g i ( X k , Y k ) g^i(X_k,Y_k) gi(Xk,Yk) 无偏于模型 F i F_{i} Fi,我们需要在没有 X k X_k Xk 参与的情况下对模型 F i F_{i} Fi 进行训练。由于我们需要对所有训练样本计算无偏的梯度估计,乍看起来对于 F i F_{i} Fi 的训练不能使用任何样本,貌似无法实现的样子。我们运用下面这个技巧来处理这个问题:对于每一个样本 X k X_k Xk,我们训练一个单独的模型 M k M_k Mk ,且该模型从不使用基于该样本的梯度估计进行更新。我们使用 M k M_k Mk 来估计 X k X_{k} Xk 上的梯度,并使用这个估计对结果树进行评分。用伪码描述如下,其中 L o s s ( y j , a ) Loss(y_{j},a) Loss(yj,a) 是需要优化的损失函数, y y y 是标签值, a a a 是公式计算值。
    在这里插入图片描述

    4. 预测偏移和排序提升

    4.1 预测偏移

    对于学习预测偏移的内容,我提出了两个问题:

    • 什么是预测偏移?
    • 用什么办法解决预测偏移问题?

    预测偏移(Prediction shift)是由梯度偏差造成的。在GDBT的每一步迭代中, 损失函数使用相同的数据集求得当前模型的梯度, 然后训练得到基学习器, 但这会导致梯度估计偏差, 进而导致模型产生过拟合的问题。 CatBoost通过采用排序提升 (Ordered boosting) 的方式替换传统算法中梯度估计方法,进而减轻梯度估计的偏差,提高模型的泛化能力。下面我们对预测偏移进行详细的描述和分析。

    首先来看下GBDT的整体迭代过程:

    GBDT算法是通过一组分类器的串行迭代,最终得到一个强学习器,以此来进行更高精度的分类。它使用了前向分布算法,弱学习器使用分类回归树(CART)。

    假设前一轮迭代得到的强学习器是 F t − 1 ( x ) F^{t−1}(x) Ft1(x) , 损失函数是 L ( y , F t − 1 ( x ) ) L(y,{F^{t - 1}}(x)) L(y,Ft1(x)) ,则本轮迭代的目的是找到一个CART回归树模型的弱学习器 h t {h^t} ht ,让本轮的损失函数最小。式(1)表示的是本轮迭代的目标函数 h t {h^t} ht

    h t = arg ⁡ min ⁡ h ∈ H E L ( ( y , F t − 1 ( x ) + h ( x ) ) ) (1) {h^t} = \mathop {\arg \min }\limits_{h \in H} EL\left( {\left( {y,{F^{t - 1}}\left( x \right) + h\left( x \right)} \right)} \right) \tag{1} ht=hHargminEL((y,Ft1(x)+h(x)))(1)

    GBDT使用损失函数的负梯度来拟合每一轮的损失的近似值,式(2)中 g t ( x , y ) {g^t}(x,y) gt(x,y) 表示的是上述梯度。

    g t ( x , y ) = ∂ L ( y , s ) ∂ s ∣ s = F t − 1 ( x ) (2) {g^t}(x,y) = \frac{{\partial L(y,s)}}{{\partial s}}{|_{s = {F^{t - 1}}(x)}} \tag{2} gt(x,y)=sL(y,s)s=Ft1(x)(2)

    通常用式(3)近似拟合 h t {h^t} ht

    h t = arg ⁡ min ⁡ h ∈ H E ( − g t ( x , y ) − h ( x ) ) 2 (3) {h^t} = \mathop {\arg \min }\limits_{h \in H} E{( - {g^t}(x,y) - h(x))^2} \tag{3} ht=hHargminE(gt(x,y)h(x))2(3)

    最终得到本轮的强学习器,如式(4)所示:

    F t ( x ) = F t − 1 ( x ) + h t (4) {F^t}(x) = {F^{t - 1}}(x) + {h^t} \tag{4} Ft(x)=Ft1(x)+ht(4)

    在这个过程当中,偏移是这样发生的:

    根据 D \ { X k } \mathbb{D} \backslash \{X_k\} D\{Xk} 进行随机计算的条件分布 g t ( X k , y k ) ∣ X k g^t(X_k,y_k)|X_k gt(Xk,yk)Xk 与测试集的分布 g t ( X , y ) ∣ X g^t(X,y)|X gt(X,y)X 发生偏移,这样由公式(3)定义的基学习器 h t h^t ht 与公式(1)定义的产生偏差,最后影响模型 F t F^t Ft 的泛化能力。

    4.2 排序提升

    为了克服预测偏移问题,CatBoost提出了一种新的叫做Ordered boosting的算法。
    在这里插入图片描述
    由上图的Ordered boosting算法可知,为了得到无偏梯度估计, CatBoost对每一个样本 x i {x_i} xi 都会训练一个单独的模型 M i {M_i} Mi ,模型 M i {M_i} Mi 由使用不包含样本 x i {x_i} xi的训练集训练得到。我们使用 M i {M_i} Mi 来得到关于样本的梯度估计,并使用该梯度来训练基学习器并得到最终的模型。

    Ordered boosting算法好是好,但是在大部分的实际任务当中都不具备使用价值,因为需要训练 n n n 个不同的模型,大大增加的内存消耗和时间复杂度。在CatBoost当中,我们以决策树为基学习器的梯度提升算法的基础上,对该算法进行了改进。

    前面提到过,在传统的GBDT框架当中,构建下一棵树分为两个阶段:选择树结构和在树结构固定后计算叶子节点的值。CatBoost主要在第一阶段进行优化。在建树的阶段,CatBoost有两种提升模式,Ordered和Plain。Plain模式是采用内建的ordered TS对类别型特征进行转化后的标准GBDT算法。Ordered则是对Ordered boosting算法的优化。两种提升模式的具体介绍可以翻看论文《CatBoost: unbiased boosting with categorical features》。

    5. 快速评分

    CatBoost使用对称树(oblivious trees)作为基预测器。在这类树中,相同的分割准则在树的整个一层上使用。这种树是平衡的,不太容易过拟合。梯度提升对称树被成功地用于各种学习任务中。在对称树中,每个叶子节点的索引可以被编码为长度等于树深度的二进制向量。这在CatBoost模型评估器中得到了广泛的应用:我们首先将所有浮点特征、统计信息和独热编码特征进行二值化,然后使用二进制特征来计算模型预测值。

    6. 基于GPU实现快速训练

    • 密集的数值特征。 对于任何GBDT算法而言,最大的难点之一就是搜索最佳分割。尤其是对于密集的数值特征数据集来说,该步骤是建立决策树时的主要计算负担。CatBoost使用oblivious 决策树作为基模型,并将特征离散化到固定数量的箱子中以减少内存使用。就GPU内存使用而言,CatBoost至少与LightGBM一样有效。主要改进之处就是利用了一种不依赖于原子操作的直方图计算方法。
    • 类别型特征。 CatBoost实现了多种处理类别型特征的方法,并使用完美哈希来存储类别型特征的值,以减少内存使用。由于GPU内存的限制,在CPU RAM中存储按位压缩的完美哈希,以及要求的数据流、重叠计算和内存等操作。通过哈希来分组观察。在每个组中,我们需要计算一些统计量的前缀和。该统计量的计算使用分段扫描GPU图元实现。
    • 多GPU支持。 CatBoost中的GPU实现可支持多个GPU。分布式树学习可以通过数据或特征进行并行化。CatBoost采用多个学习数据集排列的计算方案,在训练期间计算类别型特征的统计数据。

    7. CatBoost的优缺点

    7.1 优点

    • 性能卓越: 在性能方面可以匹敌任何先进的机器学习算法;
    • 鲁棒性/强健性: 它减少了对很多超参数调优的需求,并降低了过度拟合的机会,这也使得模型变得更加具有通用性;
    • 易于使用: 提供与scikit集成的Python接口,以及R和命令行界面;
    • 实用: 可以处理类别型、数值型特征;
    • 可扩展: 支持自定义损失函数;

    7.2 缺点

    • 对于类别型特征的处理需要大量的内存和时间;
    • 不同随机数的设定对于模型预测结果有一定的影响;

    8. CatBoost实例

    本篇文章所有数据集和代码均在我的GitHub中,地址:https://github.com/Microstrong0305/WeChat-zhihu-csdnblog-code/tree/master/Ensemble%20Learning/CatBoost

    8.1 安装CatBoost依赖包

    pip install catboost
    

    8.2 CatBoost分类

    (1)数据集

    这里我使用了 2015 年航班延误的 Kaggle 数据集,其中同时包含类别型变量和数值变量。这个数据集中一共有约 500 万条记录,我使用了 1% 的数据:5 万行记录。数据集官方地址:https://www.kaggle.com/usdot/flight-delays#flights.csv 。以下是建模使用的特征:

    • 月、日、星期: 整型数据
    • 航线或航班号: 整型数据
    • 出发、到达机场: 数值数据
    • 出发时间: 浮点数据
    • 距离和飞行时间: 浮点数据
    • 到达延误情况: 这个特征作为预测目标,并转为二值变量:航班是否延误超过 10 分钟

    实验说明: 在对 CatBoost 调参时,很难对类别型特征赋予指标。因此,同时给出了不传递类别型特征时的调参结果,并评估了两个模型:一个包含类别型特征,另一个不包含。如果未在cat_features参数中传递任何内容,CatBoost会将所有列视为数值变量。注意,如果某一列数据中包含字符串值,CatBoost 算法就会抛出错误。另外,带有默认值的 int 型变量也会默认被当成数值数据处理。在 CatBoost 中,必须对变量进行声明,才可以让算法将其作为类别型变量处理。

    (2)不加Categorical features选项的代码

    import pandas as pd, numpy as np
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn import metrics
    import catboost as cb
    
    # 一共有约 500 万条记录,我使用了 1% 的数据:5 万行记录
    # data = pd.read_csv("flight-delays/flights.csv")
    # data = data.sample(frac=0.1, random_state=10)  # 500->50
    # data = data.sample(frac=0.1, random_state=10)  # 50->5
    # data.to_csv("flight-delays/min_flights.csv")
    
    # 读取 5 万行记录
    data = pd.read_csv("flight-delays/min_flights.csv")
    print(data.shape)  # (58191, 31)
    
    data = data[["MONTH", "DAY", "DAY_OF_WEEK", "AIRLINE", "FLIGHT_NUMBER", "DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT", "AIR_TIME", "DEPARTURE_TIME", "DISTANCE", "ARRIVAL_DELAY"]]
    data.dropna(inplace=True)
    
    data["ARRIVAL_DELAY"] = (data["ARRIVAL_DELAY"] > 10) * 1
    
    cols = ["AIRLINE", "FLIGHT_NUMBER", "DESTINATION_AIRPORT", "ORIGIN_AIRPORT"]
    for item in cols:
        data[item] = data[item].astype("category").cat.codes + 1
    
    train, test, y_train, y_test = train_test_split(data.drop(["ARRIVAL_DELAY"], axis=1), data["ARRIVAL_DELAY"],
                                                    random_state=10, test_size=0.25)
    
    cat_features_index = [0, 1, 2, 3, 4, 5, 6]
    
    
    def auc(m, train, test):
        return (metrics.roc_auc_score(y_train, m.predict_proba(train)[:, 1]),
                metrics.roc_auc_score(y_test, m.predict_proba(test)[:, 1]))
    
    
    # 调参,用网格搜索调出最优参数
    params = {'depth': [4, 7, 10],
              'learning_rate': [0.03, 0.1, 0.15],
              'l2_leaf_reg': [1, 4, 9],
              'iterations': [300, 500]}
    cb = cb.CatBoostClassifier()
    cb_model = GridSearchCV(cb, params, scoring="roc_auc", cv=3)
    cb_model.fit(train, y_train)
    # 查看最佳分数
    print(cb_model.best_score_)  # 0.7088001891107445
    # 查看最佳参数
    print(cb_model.best_params_)  # {'depth': 4, 'iterations': 500, 'l2_leaf_reg': 9, 'learning_rate': 0.15}
    
    # With Categorical features,用最优参数拟合数据
    clf = cb.CatBoostClassifier(eval_metric="AUC", depth=4, iterations=500, l2_leaf_reg=9,
                                learning_rate=0.15)
    
    clf.fit(train, y_train)
    
    print(auc(clf, train, test))  # (0.7809684655761157, 0.7104617034553192)
    

    (3)有Categorical features选项的代码

    import pandas as pd, numpy as np
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn import metrics
    import catboost as cb
    
    # 读取 5 万行记录
    data = pd.read_csv("flight-delays/min_flights.csv")
    print(data.shape)  # (58191, 31)
    
    data = data[["MONTH", "DAY", "DAY_OF_WEEK", "AIRLINE", "FLIGHT_NUMBER", "DESTINATION_AIRPORT",
                 "ORIGIN_AIRPORT", "AIR_TIME", "DEPARTURE_TIME", "DISTANCE", "ARRIVAL_DELAY"]]
    data.dropna(inplace=True)
    
    data["ARRIVAL_DELAY"] = (data["ARRIVAL_DELAY"] > 10) * 1
    
    cols = ["AIRLINE", "FLIGHT_NUMBER", "DESTINATION_AIRPORT", "ORIGIN_AIRPORT"]
    for item in cols:
        data[item] = data[item].astype("category").cat.codes + 1
    
    train, test, y_train, y_test = train_test_split(data.drop(["ARRIVAL_DELAY"], axis=1), data["ARRIVAL_DELAY"],
                                                    random_state=10, test_size=0.25)
    
    cat_features_index = [0, 1, 2, 3, 4, 5, 6]
    
    
    def auc(m, train, test):
        return (metrics.roc_auc_score(y_train, m.predict_proba(train)[:, 1]),
                metrics.roc_auc_score(y_test, m.predict_proba(test)[:, 1]))
    
    
    # With Categorical features
    clf = cb.CatBoostClassifier(eval_metric="AUC", one_hot_max_size=31, depth=4, iterations=500, l2_leaf_reg=9,
                                learning_rate=0.15)
    clf.fit(train, y_train, cat_features=cat_features_index)
    
    print(auc(clf, train, test))  # (0.7817912095285117, 0.7152541135019913)
    

    8.3 CatBoost回归

    from catboost import CatBoostRegressor
    
    # Initialize data
    
    train_data = [[1, 4, 5, 6],
                  [4, 5, 6, 7],
                  [30, 40, 50, 60]]
    
    eval_data = [[2, 4, 6, 8],
                 [1, 4, 50, 60]]
    
    train_labels = [10, 20, 30]
    # Initialize CatBoostRegressor
    model = CatBoostRegressor(iterations=2,
                              learning_rate=1,
                              depth=2)
    # Fit model
    model.fit(train_data, train_labels)
    # Get predictions
    preds = model.predict(eval_data)
    print(preds)
    

    9. 关于CatBoost若干问题思考

    9.1 CatBoost与XGBoost、LightGBM的联系与区别?

    (1)2014年3月XGBoost算法首次被陈天奇提出,但是直到2016年才逐渐著名。2017年1月微软发布LightGBM第一个稳定版本。2017年4月Yandex开源CatBoost。自从XGBoost被提出之后,很多文章都在对其进行各种改进,CatBoost和LightGBM就是其中的两种。

    (2)CatBoost处理类别型特征十分灵活,可直接传入类别型特征的列标识,模型会自动将其使用One-hot编码,还可通过设置 one_hot_max_size参数来限制One-hot特征向量的长度。如果不传入类别型特征的列标识,那么CatBoost会把所有列视为数值特征。对于One-hot编码超过设定的one_hot_max_size值的特征来说,CatBoost将会使用一种高效的encoding方法,与mean encoding类似,但是会降低过拟合。处理过程如下:

    • 将输入样本集随机排序,并生成多组随机排列的情况;
    • 将浮点型或属性值标记转化为整数;
    • 将所有的类别型特征值结果都根据以下公式,转化为数值结果;

    a v g _ t a r g e t = c o u n t I n C l a s s + p r i o r t o t a l C o u n t + 1 avg\_target = \frac{countInClass + prior}{totalCount + 1} \\ avg_target=totalCount+1countInClass+prior

    其中 countInClass 表示在当前类别型特征值中有多少样本的标记值是 1 1 1;prior 是分子的初始值,根据初始参数确定。totalCount 是在所有样本中(包含当前样本)和当前样本具有相同的类别型特征值的样本数量。

    LighGBM 和 CatBoost 类似,也可以通过使用特征名称的输入来处理类别型特征数据,它没有对数据进行独热编码,因此速度比独热编码快得多。LighGBM 使用了一个特殊的算法来确定属性特征的分割值。

    train_data = lgb.Dataset(data, label=label, feature_name=['c1', 'c2', 'c3'], categorical_feature=['c3'])
    

    注意,在建立适用于 LighGBM 的数据集之前,需要将类别型特征变量转化为整型变量,此算法不允许将字符串数据传给类别型变量参数。

    XGBoost 和 CatBoost、 LighGBM 算法不同,XGBoost 本身无法处理类别型特征,而是像随机森林一样,只接受数值数据。因此在将类别型特征数据传入 XGBoost 之前,必须通过各种编码方式:例如,序号编码、独热编码和二进制编码等对数据进行处理。

    10. Reference

    CatBoost论文解读:

    【1】Prokhorenkova L, Gusev G, Vorobev A, et al. CatBoost: unbiased boosting with categorical features[C]//Advances in Neural Information Processing Systems. 2018: 6638-6648.
    【2】Dorogush A V, Ershov V, Gulin A. CatBoost: gradient boosting with categorical features support[J]. arXiv preprint arXiv:1810.11363, 2018.
    【3】机器学习算法之Catboost,地址:https://www.biaodianfu.com/catboost.html
    【4】oblivious tree在机器学习中有什么用? - 李大猫的回答 - 知乎 https://www.zhihu.com/question/311641149/answer/593286799
    【5】CatBoost算法梳理,地址:http://datacruiser.io/2019/08/19/DataWhale-Workout-No-8-CatBoost-Summary/

    CatBoost算法讲解:

    【6】catboost完全指南,地址:https://zhuanlan.zhihu.com/p/102570430
    【7】CatBoost原理及实践 - Dukey的文章 - 知乎 https://zhuanlan.zhihu.com/p/37916954
    【8】 22(7).模型融合—CatBoost,地址:https://www.cnblogs.com/nxf-rabbit75/p/10923549.html#auto_id_0
    【9】catboost对类别特征处理的简单总结,地址:https://blog.csdn.net/weixin_42944192/article/details/102463796
    【10】Python3机器学习实践:集成学习之CatBoost - AnFany的文章 - 知乎 https://zhuanlan.zhihu.com/p/53591724

    CatBoost实战:

    【11】Catboost 一个超级简单实用的boost算法,地址:https://www.jianshu.com/p/49ab87122562
    【12】苗丰顺, 李岩, 高岑, 王美吉, 李冬梅. 基于CatBoost算法的糖尿病预测方法. 计算机系统应用, 2019, 28(9): 215-218.http://www.c-s-a.org.cn/1003-3254/7054.html
    【13】Battle of the Boosting Algos: LGB, XGB, Catboost,地址: https://www.kaggle.com/lavanyashukla01/battle-of-the-boosting-algos-lgb-xgb-catboost
    【14】Simple CatBoost,地址:https://www.kaggle.com/nicapotato/simple-catboost
    【15】CatBoost Usage examples,地址:https://catboost.ai/docs/concepts/python-usages-examples.html

    CatBoost的若干思考:

    【16】入门 | 从结构到性能,一文概述XGBoost、Light GBM和CatBoost的同与不同,地址:https://mp.weixin.qq.com/s/TD3RbdDidCrcL45oWpxNmw

    展开全文
  • 30分钟学会CatBoost

    千次阅读 2022-01-24 01:17:22
    一,CatBoost简介 CatBoost和XGBoost、LightGBM并称为GBDT的三大主流神器,都是在GBDT算法框架下的一种改进实现。正如其名字所说那样,CatBoost主要是...

    一,CatBoost简介

    CatBoost和XGBoost、LightGBM并称为GBDT的三大主流神器,都是在GBDT算法框架下的一种改进实现。

    正如其名字所说那样,CatBoost主要是在类别特征上的处理上做了很多的改进。

    从用户使用角度来看,相比XGBoost和LightGBM,CatBoost具有如下特点。

    • 模型精度:XGBoost和LightGBM相当,CatBoost往往略好一些,无需调参即可获取很好的结果。

    • 训练速度:LightGBM远快于XGBoost,CatBoost快于XGBoost但比LightGBM慢。

    • 预测速度:LightGBM与XGBoost相当,CatBoost远快于LightGBM与XGBoost,是它们的几十分之一。

    • 内存消耗:LightGBM远小于XGBoost,CatBoost小于XGBoost,但大于LightGBM。

    • 类别特征:XGBoost不支持类别特征,需要OneHot编码预处理。LightGBM支持类别特征,需转换成整数编码。CatBoost提供更强大的对类别特征的支持,直接支持字符串类型的类别特征,无需预处理。

    • 缺失值特征:XGBoost和LightGBM都可以自动处理特征缺失值,CatBoost不能自动处理缺失值(或者将缺失值视为最小值/最大值)。

    • GPU支持:LightGBM与CatBoost支持GPU训练,XGBoost也支持GPU训练。

    • 可视化:CatBoost还自带一套可视化工具,可以在Jupyter Notebook或者TensorBoard中实时看到指标变化。

    CatBoost主要创新点如下:

    • 类别特征的 Ordered Target Statistics 数值编码方法。

    • 基于贪心策略的特征组合方法。

    • 避免预测偏移的 Ordered Boosting 方法。

    • 使用对称二叉树作为基模型,有正则作用且预测极快。

    eafdb015beeb8a6625e97d482ef9667a.png

    二,原理说明

    1, 类别特征的Ordered Target Statistics 数值编码方法

    对于类别特征,如果类别数目不多,可以使用onehot编码。

    但如果类别数量成百上千,使用onehot编码会导致特征数量爆炸。

    CatBoost设计了一种基于预测目标统计值的方法可以将类别特征转化为数值特征。

    以风控领域的预测信贷用户是否会违约为例,假设有一个类别特征是根据身份证号码解析出来的用户所出生的城市。

    全国有几百个城市,转化为onehot编码会造成特征维数爆炸。

    一种非常make sense 的方式是我们用某个城市用户的平均逾期率来作为该城市的数值特征编码。

    简而言之,我们用如下方式将 city = "上海" 这一类别特征取值 代替为如下值。

    city_numeric("上海") = sample_count(city="上海" and label=1(逾期)) / sample_count(city="上海")

    这就是所谓的 Target Statistics 编码方法。

    但是考虑到有一些小城市,比如黑龙江鹤岗市,可能在训练样本中数量很少甚至没有,这时候用训练样本中鹤岗市的用户平均逾期率来估计会比较不靠谱。

    例如鹤岗市只有1个样本,并且这个样本是逾期的,那么数值编码

    city_numeric("鹤岗") = sample_count(city="鹤岗" and label=1(逾期)) / sample_count(city="鹤岗") = 1.0

    我们可以考虑加入先验值来抑制这种小样本的波动。

    假设不区分城市,全部训练样本中用户的 逾期率 为 P = 0.1, 我们可以在分子分母上分别加入 a = 100个 逾期率为P 的先验样本。

    city_numeric("鹤岗") = (sample_count(city="鹤岗" and label=1(逾期)) + a·P) / (sample_count(city="鹤岗")+ a) = 11/101

    这样就合理多了。

    这种数值编码方式虽然好,但是会造成训练集中 label的泄露,因为对于某个样本来说,其数值编码计算过程中已经把这个样本的 label值纳入了计算过程中。

    未来要预测的验证集的数据分布未必与训练集相同,例如训练集中 上海市 用户的平均逾期率为 0.12,但是验证集中上海市用户的平均逾期率可能只有0.04,在训练集中这个 city_numeric特征可能会特别好用,特别重要,但是在验证集中可能会变得没有那么好用,没有那么重要。

    为了让模型正确地评估 city_numeric 特征的真实有效性和重要程度,我们可以拿出一部分数据来计算这个 特征编码,用另外一部分数据来训练。但是这样会造成可用数据的减少。

    CatBoost巧妙地设计了如下trick,来缓解这个问题。先将样本随机打乱,然后每个样本只使用它排序在它前面的样本来计算其类别特征的数值编码。这样就防止了label的泄露,并且能够较为合理地评估 这个特征的真实有效性。

    不过这种方式会造成排在前面的样本的类别特征的数值编码估计不是很准,为了减少这个影响,CatBoost会设计多个样本随机排列(默认4个),在每次建树前从中随机取一个排列。

    以上就是所谓的 Ordered Target Statistics 编码方法,也是CatBoost最重要的创新。

    516c42912cf9adbb2d06495e165f7466.png

    2,基于贪心策略的特征交叉方法

    使用Ordered Target Statistics 方法将类别特征转化成为数值特征以后,会影响到特征交叉,因为数值特征无法有效地进行交叉。

    依然以风控领域的预测信贷用户是否会违约为例,假设 city="北京市" 且 job="保安" 的用户信用特别好,但不是北京市所有的用户都信用好,也不是所有的保安都信用特别好。只有北京市的保安这个群体才信用好。

    如果我们将 city转换为数值编码,也将保安转换为数值编码之后,我们得到两个数,这两个数相乘是没有意义的,我们无法表示 北京市的保安这个群体。

    为了有效地利用特征交叉,CatBoost 在将类别特征转换为数值编码的同时,会自动生成 交叉特征。

    如果让全部的类别特征之间都进行交叉,两两交叉,三三交叉,四四交叉,这个复杂度是指数级的,特征维度一定会爆炸。

    CatBoost使用一种贪心的策略来进行特征交叉。生成tree的第一次分裂,CatBoost不使用任何交叉特征。在后面的分裂中,CatBoost会使用生成tree所用到的全部原始特征和交叉特征 跟 数据集中的全部 类别特征进行交叉。

    在定义CatBoost模型时,我们可以用'max_ctr_complexity' 来控制允许的特征交叉的最大特征数量,如果设置为3,那么生成tree时所用到的交叉特征最多只会来自3个特征的交叉,也就是我们只能表示 city='北京市' 且 job='保安' 且 education='高中'这样的三阶交叉特征,而无法表示  city='北京市' 且 job='保安' 且 education='高中' 且 hobby='抽烟' 这样的四阶交叉特征。

    3,避免预测偏移的 Ordered Boosting 方法。

    使用XGBoost或者LightGBM做模型时,我们可能经常会发现模型在训练集上拟合的很好,train_auc甚至达到了1.0, 但是在验证集上却差了很多, va_auc 可能只有0.7。这当然有可能是因为tree的数量太多了,或者是每棵tree的leaves太多了,总之模型太复杂了造成了过拟合。

    但也有一些XGBoost和LightGBM自身算法的缺陷因素。我们知道LightGBM在训练下一棵tree的时候,需要计算前面这些tree构成的加法模型在所有样本上的一阶梯度和二阶梯度(Loss对模型预测结果的导数),然后用这些梯度来决定下一棵树的结构和叶子节点取值。

    但是我们计算的这些一阶梯度和二阶梯度值是问题的。前面的这些tree都是在这些样本上训练的,现在我们又在这些样本上估计模型预测结果的一阶和二阶梯度。我们应该换一些新的样本才更合理。但是我们从哪里找这些新的样本呢?

    CatBoost 的作者故伎重演。先将样本随机打乱,然后每个样本只使用排序在它前面的样本来训练模型。用这样的模型来估计这个样本预测结果的一阶和二阶梯度。然后用这些梯度构建一棵tree的结构,最终tree的每个叶子节点的取值,是使用全体样本进行计算的。

    这就是Ordered Boosting的主要思想。可以有效地减少梯度估计的误差,缓解预测偏移。但是会增加较多的计算量,影响训练速度。

    在定义CatBoost模型时,我们可以用'boosting_type'这个参数来设置是使用Ordered Boosting 还是 LightGBM那样的 Plain Boosting。如果不显式设置,CatBoost会根据样本和特征数量自己决定。

    a9a7679d2cb6be377668c838b4f4838e.png

    4,使用对称二叉树作为基模型,有正则作用且预测极快

    XGBoost和LightGBM采用的基模型是普通的二叉树,但是CatBoost采用的是对称的二叉树。

    这种对树结构上的约束有一定的正则作用。更为重要的是,它可以让CatBoost模型的推断过程极快。

    对于CatBoost的tree的预测过程来说,每个特征的分裂都是独立的,不分先后顺序,多个样本可以一起预测。

    85c1d41c20b6a6dd7c9ad75d75431c25.png

    三,使用范例

    #!pip install catboost 
    import catboost as cb 
    print(cb.__version__)

    1.0.4

    from IPython.display import display 
    
    import datetime,json
    import numpy as np
    import pandas as pd
    import catboost as cb 
    from catboost.datasets import titanic
    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.model_selection import StratifiedKFold
    
    from sklearn.metrics import f1_score,roc_auc_score,accuracy_score
    import plotly.graph_objs as go 
    import plotly.express as px 
    
    
    def printlog(info):
        nowtime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        print("\n"+"=========="*8 + "%s"%nowtime)
        print(info+'...\n\n')
         
    #================================================================================
    # 一,准备数据
    #================================================================================
    printlog("step1: preparing data...")
    
    dfdata,dftest = titanic()
    
    display(dfdata.head()) 
    
    label_col = "Survived"
    
    # 填充空值特征
    dfnull = pd.DataFrame(dfdata.isnull().sum(axis=0),columns = ["null_cnt"]).query("null_cnt>0")
    print("null_features:") 
    print(dfnull)
    
    dfdata.fillna(-9999, inplace=True)
    dftest.fillna(-9999, inplace=True)
    
    
    # 刷选类别特征
    cate_cols = [x for x in dfdata.columns 
                 if dfdata[x].dtype not in [np.float32,np.float64] and x!=label_col]
    for col in cate_cols:
        dfdata[col] = pd.Categorical(dfdata[col]) 
        dftest[col] = pd.Categorical(dftest[col]) 
    
    # 分割数据集
    dftrain,dfvalid = train_test_split(dfdata, train_size=0.75, random_state=42)
    Xtrain,Ytrain = dftrain.drop(label_col,axis = 1),dftrain[label_col]
    Xvalid,Yvalid = dfvalid.drop(label_col,axis = 1),dfvalid[label_col]
    cate_cols_indexs = np.where(Xtrain.columns.isin(cate_cols))[0]
    
    
    # 整理成Pool
    pool_train = cb.Pool(data = Xtrain, label = Ytrain, cat_features=cate_cols)
    pool_valid = cb.Pool(data = Xvalid, label = Yvalid, cat_features=cate_cols)
    
    
    #================================================================================
    # 二,设置参数
    #================================================================================
    printlog("step2: setting parameters...")
                                   
    iterations = 1000
    early_stopping_rounds = 200
    
    params = {
        'learning_rate': 0.05,
        'loss_function': "Logloss",
        'eval_metric': "Accuracy",
        'depth': 6,
        'min_data_in_leaf': 20,
        'random_seed': 42,
        'logging_level': 'Silent',
        'use_best_model': True,
        'one_hot_max_size': 5,   #类别数量多于此数将使用ordered target statistics编码方法,默认值为2。
        'boosting_type':"Ordered", #Ordered 或者Plain,数据量较少时建议使用Ordered,训练更慢但能够缓解梯度估计偏差。
        'max_ctr_complexity': 2, #特征组合的最大特征数量,设置为1取消特征组合,设置为2只做两个特征的组合,默认为4。
        'nan_mode': 'Min' 
    }
    
    
    #================================================================================
    # 三,训练模型
    #================================================================================
    printlog("step3: training model...")
    
    
    model = cb.CatBoostClassifier(
        iterations = iterations,
        early_stopping_rounds = early_stopping_rounds,
        train_dir='catboost_info/',
        **params
    )
    
    
    #直接训练
    model.fit(
        pool_train,
        eval_set=pool_valid,
        plot=True
    )
    
    print("model.get_all_params():")
    print(model.get_all_params() )
    
    
    #5折交叉验证
    cv_data= cb.cv(
        cb.Pool(dfdata.drop(label_col,axis = 1), dfdata[label_col], cat_features=cate_cols_indexs),
        params,
        fold_count = 3,
        plot=True
    )
    
    print('Best validation accuracy score: {:.2f}±{:.2f} on step {}'.format(
        np.max(cv_data['test-Accuracy-mean']),
        cv_data['test-Accuracy-std'][np.argmax(cv_data['test-Accuracy-mean'])],
        np.argmax(cv_data['test-Accuracy-mean'])
    ))
    
    
    #================================================================================
    # 四,评估模型
    #================================================================================
    printlog("step4: evaluating model ...")
    
    
    y_pred_train = model.predict(Xtrain)
    y_pred_valid = model.predict(Xvalid)
    
    train_score = f1_score(Ytrain,y_pred_train)
    valid_score = f1_score(Yvalid,y_pred_valid)
    
    
    print('train f1_score: {:.5} '.format(train_score))
    print('valid f1_score: {:.5} \n'.format(valid_score))   
    
    
    
    #feature importance 
    dfimportance = model.get_feature_importance(prettified=True) 
    dfimportance = dfimportance.sort_values(by = "Importances").iloc[-20:]
    fig_importance = px.bar(dfimportance,x="Importances",y="Feature Id",title="Feature Importance")
    
    display(dfimportance)
    display(fig_importance)
    
    
    #score distribution
    y_test_prob = model.predict_proba(dftest)[:,-1]
    trace1 = go.Histogram(x = y_test_prob,histnorm = 'probability',nbinsx=50)
    layout = go.Layout(title = "Score Distribution",xaxis={"title":"score"},yaxis = {"title":"frequecy"})
    fig_distribution = go.Figure(data = [trace1])
    fig_distribution.update_layout(layout)
    display(fig_distribution)
    
    
    #================================================================================
    # 五,使用模型
    #================================================================================
    printlog("step5: using model ...")
    
    y_pred_test = model.predict(dftest)
    y_pred_test_prob = model.predict_proba(dftest)
    
    print("y_pred_test:\n",y_pred_test[:10])
    print("y_pred_test_prob:\n",y_pred_test_prob[:10])
    
    #================================================================================
    # 六,保存模型
    #================================================================================
    printlog("step6: saving model ...")
    
    model_dir = 'catboost_model'
    model.save_model(model_dir)
    model_loaded = cb.CatBoostClassifier()
    model.load_model(model_dir)

    86416363f40aa8ef243bb731a8ed0525.png

    c096a99b0c42389c66ce36b61df38a56.png

    f1097910332858192096ac970a1ab631.png

    公众号后台回复关键词:CatBoost,获取本文全部代码和插图。

    万水千山总是情,点个在看行不行?😋 😋 

    展开全文
  • 资源分类:Python库 所属语言:Python 资源全名:catboost-0.7-cp34-none-win_amd64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • CatBoost

    千次阅读 2019-05-09 15:45:38
    文章目录1.CatBoost是什么?2.CatBoost有哪些优点?3.CatBoost实例展示4.参考 1.CatBoost是什么? CatBoost是俄罗斯的搜索巨头Yandex在2017年开源的机器学习库,是Gradient Boosting(梯度提升) + Categorical ...
  • 资源分类:Python库 所属语言:Python 资源全名:catboost-0.14.2-cp35-none-win_amd64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • Catboost参数

    2021-08-05 11:55:08
    CatBoost是一种基于对称决策树(oblivious trees)为基学习器实现的参数较少、支持类别型变量和高准确性的GBDT框架,主要解决的痛点是高效合理地处理类别型特征,这一点从它的名字中可以看出来,CatBoost是由...
  • CatBoost教程 基本的 最好从此基础教程开始进行CatBoost探索。 Python 本教程介绍了使用CatBoost的一些基本情况,例如模型训练,交叉验证和预测,以及一些有用的功能,如提早停止,快照支持,功能重要性和参数调整...
  • java依赖包下载
  • 资源分类:Python库 所属语言:Python 资源全名:catboost-1.0.3-cp310-none-manylinux1_x86_64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • 资源分类:Python库 所属语言:Python 资源全名:catboost-0.2-cp35-none-manylinux1_x86_64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • CatBoost和XGBoost、LightGBM并称为GBDT的三大主流神器,都是在GBDT算法框架下的一种改进实现。 正如其名字所说那样,CatBoost主要是在类别特征上的处理上做了很多的改进。 从用户使用角度来看,相比XGBoost和Light...
  • 资源分类:Python库 所属语言:Python 使用前提:需要解压 资源全名:catboost-0.17.4-cp27-none-manylinux1_x86_64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • 资源分类:Python库 所属语言:Python 资源全名:catboost_dev-0.20.1.7661-cp36-none-win_amd64.whl 资源来源:官方 安装方法:https://lanzao.blog.csdn.net/article/details/101784059
  • catboost原理

    千次阅读 多人点赞 2020-02-20 21:32:24
    文章目录概述原理类别型特征类别型特征的相关工作目标变量统计(Target Statistics)CatBoost处理Categorical features总结梯度偏差/预测偏移为什么会有梯度偏差?梯度偏差造成了什么问题?如何解决梯度偏差/预测...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,194
精华内容 4,477
关键字:

CatBoost