spark GBT算法

最新推荐文章于 2024-07-14 08:52:33 发布
最新推荐文章于 2024-07-14 08:52:33 发布
阅读量576 收藏 1
点赞数
文章标签： 大数据 数据结构与算法 人工智能
原文链接：https://my.oschina.net/u/3455048/blog/1358310
版权

梯度增强树（GBT）是使用决策树组合的流行回归方法

相对于Random forest 来说GBT在实际应用中，效果更好

直接上代码

package mllib

import org.apache.spark.ml.Pipeline
import org.apache.spark.ml.classification.GBTClassifier
import org.apache.spark.ml.evaluation.MulticlassClassificationEvaluator
import org.apache.spark.ml.feature._
import org.apache.spark.sql.SparkSession

/**
  * Created by dongdong on 17/7/10.
  */

case class Fearture_One(
                         cid: String,
                         population_gender: String,
                         population_age: Double,
                         population_registered_gps_city: String,
                         population_education_nature: String,
                         population_university_level: String,
                         sociality_channel_type: String,
                         action_registered_channel: String,
                         action_this_month_once_week_average_login_count: Double,
                         population_censu_city: String,
                         population_gps_city: String,
                         population_own_cell_city: String,
                         population_rank1_cell_city: String,
                         population_rank1_cell_cnt: Double,
                         population_rank2_cell_city: String,
                         population_rank2_cell_cnt: Double,
                         population_rank3_cell_city: String,
                         population_rank3_cell_cnt: Double,
                         population_gps_censu_flag: Double,
                         population_own_censu_flag: Double,
                         population_gps_own_flag: Double,
                         population_own_txl_flag: Double,
                         population_gps_txl_flag: Double,
                         population_censu_txl_flag: Double,
                         population_cnt_7day_province: Double,
                         population_cnt_7day_city: Double,
                         population_cnt_login: Double,
                         population_before_apply_city: String,
                         population_after_apply_city: String,
                         population_before_in_apply_address: Double,
                         population_before_after_apply_address: Double,
                         population_in_after_apply_address: Double,
                         population_re_address_steady: String,
                         population_apply_address_steady: String,
                         population_score_fake_gps: Double,
                         population_score_fake_contacts: Double,
                         text: String,
                         flag: String
                       )

object GBT_Profile {

  def main(args: Array[String]): Unit = {
    
    val inpath1 = "/Users/ant_git/src/data/user_profile_train/part-00000"

    val spark = SparkSession
      .builder()
      .master("local[3]")
      .appName("GBT_Profile")
      .getOrCreate()
    import spark.implicits._

    //read data and transform datafram
    val originalData = spark.sparkContext
      .textFile(inpath1)
      .map(line => {
        val arr = line.split("\001")
        val cid = arr(0)
        val population_gender = arr(3).replace("\\N", "N")
        val population_age = arr(4).replace("\\N", "0").toDouble
        val population_registered_gps_city = arr(7).replace("\\N", "N")
        val population_education_nature = arr(10).replace("\\N", "N")
        val population_university_level = arr(11).replace("\\N", "N")
        val sociality_channel_type = arr(13).replace("\\N", "N")
        val action_registered_channel = arr(44).replace("\\N", "N")
        val action_this_month_once_week_average_login_count = arr(54).replace("\\N", "0").toDouble
        val population_censu_city = arr(63).replace("\\N", "N")
        val population_gps_city = arr(64).replace("\\N", "N")
        // val population_jz_city = arr(65).replace("\\N", "N")
        // val population_ip_city = arr(66).replace("\\N", "N")
        val population_own_cell_city = arr(67).replace("\\N", "N")
        val population_rank1_cell_city = arr(68).replace("\\N", "N")
        val population_rank1_cell_cnt = arr(69).replace("\\N", "0").toDouble
        val population_rank2_cell_city = arr(70).replace("\\N", "N")
        val population_rank2_cell_cnt = arr(71).replace("\\N", "0").toDouble
        val population_rank3_cell_city = arr(72).replace("\\N", "N")
        val population_rank3_cell_cnt = arr(73).replace("\\N", "0").toDouble
        //val population_jxl_call_max_city = arr(74).replace("\\N", "N")
        // val population_jxl_call_max_city_cnt = arr(75).replace("\\N", "0").toDouble
        //val population_anzhuo_30day_max_city = arr(76).replace("\\N", "N")
        //val population_anzhuo_30day_max_city_cnt = arr(77).replace("\\N", "0").toDouble
        val population_gps_censu_flag = arr(78).replace("\\N", "0").toDouble
        //val population_gps_jxl_flag = arr(79).replace("\\N", "0").toDouble
        //val population_gps_jz_flag = arr(80).replace("\\N", "0").toDouble
        //val population_ip_censu_flag = arr(81).replace("\\N", "0").toDouble
        // val population_ip_jxl_flag = arr(82).replace("\\N", "0").toDouble
        //val population_ip_jz_flag = arr(83).replace("\\N", "0").toDouble
        val population_own_censu_flag = arr(84).replace("\\N", "0").toDouble
        //val population_own_jxl_flag = arr(85).replace("\\N", "0").toDouble
        //val population_own_jz_flag = arr(86).replace("\\N", "0").toDouble
        val population_gps_own_flag = arr(87).replace("\\N", "0").toDouble
        //val population_gps_ip_flag = arr(88).replace("\\N", "0").toDouble
        //val population_ip_own_flag = arr(89).replace("\\N", "0").toDouble
        //val population_ip_txl_flag = arr(90).replace("\\N", "0").toDouble
        val population_own_txl_flag = arr(91).replace("\\N", "0").toDouble
        val population_gps_txl_flag = arr(92).replace("\\N", "0").toDouble
        val population_censu_txl_flag = arr(93).replace("\\N", "0").toDouble
        //val population_jxl_txl_flag = arr(94).replace("\\N", "0").toDouble
        //val population_jz_txl_flag = arr(95).replace("\\N", "0").toDouble
        val population_cnt_7day_province = arr(96).replace("\\N", "0").toDouble
        val population_cnt_7day_city = arr(97).replace("\\N", "0").toDouble
        val population_cnt_login = arr(102).replace("\\N", "0").toDouble
        val population_before_apply_city = arr(107).replace("\\N", "N")
        val population_after_apply_city = arr(108).replace("\\N", "N")
        val population_before_in_apply_address = arr(111).replace("\\N", "0").toDouble
        val population_before_after_apply_address = arr(112).replace("\\N", "0").toDouble
        val population_in_after_apply_address = arr(113).replace("\\N", "0").toDouble
        val population_re_address_steady = arr(116).replace("\\N", "N")
        val population_apply_address_steady = arr(117).replace("\\N", "N")
        val population_score_fake_gps = arr(127).replace("\\N", "0").toDouble
        val population_score_fake_contacts = arr(128).replace("\\N", "0").toDouble
        val text = population_gender + "|" +
          population_registered_gps_city + "|" +
          population_education_nature + "|" +
          population_university_level + "|" +
          sociality_channel_type + "|" +
          action_registered_channel + "|" +
          population_censu_city + "|" +
          population_gps_city + "|" +
          population_own_cell_city + "|" +
          population_rank1_cell_city + "|" +
          population_rank2_cell_city + "|" +
          population_rank3_cell_city + "|" +
          population_before_apply_city + "|" +
          population_after_apply_city + "|" +
          population_re_address_steady + "|" +
          population_apply_address_steady
        val flag = arr(141)
        Fearture_One(
          cid: String,
          population_gender: String,
          population_age: Double,
          population_registered_gps_city: String,
          population_education_nature: String,
          population_university_level: String,
          sociality_channel_type: String,
          action_registered_channel: String,
          action_this_month_once_week_average_login_count: Double,
          population_censu_city: String,
          population_gps_city: String,
          population_own_cell_city: String,
          population_rank1_cell_city: String,
          population_rank1_cell_cnt: Double,
          population_rank2_cell_city: String,
          population_rank2_cell_cnt: Double,
          population_rank3_cell_city: String,
          population_rank3_cell_cnt: Double,
          population_gps_censu_flag: Double,
          population_own_censu_flag: Double,
          population_gps_own_flag: Double,
          population_own_txl_flag: Double,
          population_gps_txl_flag: Double,
          population_censu_txl_flag: Double,
          population_cnt_7day_province: Double,
          population_cnt_7day_city: Double,
          population_cnt_login: Double,
          population_before_apply_city: String,
          population_after_apply_city: String,
          population_before_in_apply_address: Double,
          population_before_after_apply_address: Double,
          population_in_after_apply_address: Double,
          population_re_address_steady: String,
          population_apply_address_steady: String,
          population_score_fake_gps: Double,
          population_score_fake_contacts: Double,
          text: String,
          flag: String
        )
      }
      ).toDS


    //label to indexer
    val labelIndexer = new StringIndexer()
      .setInputCol("flag")
      .setOutputCol("indexedLabel")
      .fit(originalData)

    //splits words
    val tokenizer = new RegexTokenizer()
      .setInputCol("text")
      .setOutputCol("words")
      .setPattern("\\|")

    //words to vector
    val word2Vec = new Word2Vec()
      .setInputCol("words")
      .setOutputCol("word2feature")
      .setVectorSize(100)
      //.setMinCount(1)
      .setMaxIter(10)

    //array fields
    val arr = Array("population_age",
      "action_this_month_once_week_average_login_count",
      "population_rank1_cell_cnt",
      "population_rank2_cell_cnt",
      "population_rank3_cell_cnt",
      "population_gps_censu_flag",
      "population_own_censu_flag",
      "population_gps_own_flag",
      "population_own_txl_flag",
      "population_gps_txl_flag",
      "population_censu_txl_flag",
      "population_cnt_7day_province",
      "population_cnt_7day_city",
      "population_cnt_login",
      "population_before_in_apply_address",
      "population_before_after_apply_address",
      "population_in_after_apply_address",
      "population_score_fake_gps",
      "population_score_fake_contacts",
      "word2feature"
    )
    //merge fields to Verctor
    val vectorAssembler = new VectorAssembler()
      .setInputCols(arr)
      .setOutputCol("assemblerVector")

    //creat GBT
    val gbt = new GBTClassifier()
      .setLabelCol("indexedLabel")
      .setFeaturesCol("assemblerVector")
      //set iterator
      .setMaxIter(25)
      //set tree depth
      .setMaxDepth(5)

    val labelConverter = new IndexToString()
      .setInputCol("prediction")
      .setOutputCol("predictedLabel")
      .setLabels(labelIndexer.labels)

    val Array(trainingData, testData) = originalData.randomSplit(Array(0.8, 0.2))

    val pipeline = new Pipeline().setStages(Array(labelIndexer, tokenizer, word2Vec, vectorAssembler, gbt, labelConverter))

    val model = pipeline.fit(originalData)

    val predictionResultDF = model.transform(testData)

    predictionResultDF.show(false)

    val label_1 = predictionResultDF.select("cid", "flag", "predictedLabel")
      .filter($"flag" === 1)
      .count()

    val correct_1 = predictionResultDF.select("cid", "flag", "predictedLabel")
      .filter($"flag" === $"predictedLabel")
      .filter($"predictedLabel" === 1).count()

    val correct_0 = predictionResultDF.select("cid", "flag", "predictedLabel")
      .filter($"flag" === $"predictedLabel")
      .filter($"predictedLabel" === 0).count()

    val predicted_1 = predictionResultDF.select("cid", "predictedLabel")
      .filter($"predictedLabel" === 1)
      .repartition(1).write.format("csv").save("/Users/ant_git/Antifraud/src/data/predict/")

    val evaluator = new MulticlassClassificationEvaluator()
      .setLabelCol("indexedLabel")
      .setPredictionCol("prediction")
      .setMetricName("accuracy")
    val accuracy = evaluator.evaluate(predictionResultDF)
    val error = 1.0 - accuracy
    println("Test Error = " + (1.0 - accuracy))

    spark.stop()
  }
}

总结：算法是别人封装好的，最重要的是特征如何进行处理，好的特征，很简单的算法都可以进行分类，不好的特征，再好的模型也很难有好的效果，所以如何进行特征的选择，对于机器学习来说是非常重要的

转载于:https://my.oschina.net/u/3455048/blog/1358310

chengujun7940
关注
GBT 32905 SM3密码杂凑算法
06-18
GBT 32905 SM3 算法 标准文档 PDF。介绍国密算法SM3 得详细标准，对标SHA256，比sha256更安全。 国密标准必须了解得标准，正式国家标准
spark-GBDTs源码解析(GBDT梯度提升决策树[回归GBTClassifier|分类GBDTRegressor])_(spark_2.2.0)
u010990043的博客
07-08 3286
GBDT算法简介 【概述】 GBDT（全称梯度下降树）是集成学习中的其中一种算法。幸运的是spark在MLlib中有相关实现，共有两种实现GBTClassifier,GBDTRegressor。 【spark实现计算流程】 1. 若当前实现为GBTClassifier，检查训练集的label是否包含0和1之外的值，如果包含异常退出，否则将0和1转换成-...
机器学习中的算法(1)-决策树模型组合之随机森林与GBDT
weixin_34405557的博客
03-07 404
版权声明： 本文由LeftNotEasy发布于http://leftnoteasy.cnblogs.com, 本文可以被全部的转载或者部分使用，但请注明出处，如果有问题，请联系wheeleast@gmail.com。也可以加我的微博:@leftnoteasy 前言： 决策树这种算法有着很多良好的特性，比如说训练时间复杂度较低，预测的过程比较快速，模型容易展示（容易将得...
分类算法：梯度提升树(GBT)算法原理
最新发布
kkchenjj的博客
07-14 602
梯度提升树(GBT)是一种强大的机器学习算法，通过迭代地构建决策树并组合它们的预测结果来提高模型的预测性能。理解决策树的构建过程和回归树与分类树的区别是掌握GBT算法的关键。通过调整参数，可以有效地控制GBT模型的复杂度，避免过拟合，提高模型的泛化能力。然而，GBT的训练时间较长，解释性较差，这在实际应用中需要权衡。梯度提升树(Gradient Boosting Tree, GBT)是一种迭代的决策树算法，通过构建一系列弱分类器并组合它们来形成一个强分类器。
GBDT算法梳理
林的博客
04-07 564
GBDT有很多简称，有GBT（Gradient Boosting Tree）,GTB（Gradient Tree Boosting），GBRT（Gradient Boosting Regression Tree）, MART(Multiple Additive Regression Tree)，其实都是指的同一种算法。 加法模型： 一、前向分布算法 其中， 为基函数， 为基函数...
复盘：GBDT，梯度提升决策树，Gradient Boosting Decision Tree，堪称最好的算法之一
weixin_46838716的博客
08-25 829
1）GBDT，用弱鸡模型CART，通过预测上一个模型的残差ri=损失函数的负梯度值，不断累加和最后得到一个强模型的预测结果 2）boosting的想法，就是多个弱分类器不断串联最后得到强分类器的结果。 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。...
Chinese Std GBT7714 (numeric)
06-17
《Endnote与国标GBT7714：创建与应用有序编码制引用格式》 在学术研究和出版领域，正确引用参考文献是至关重要的。中国国家标准GB/T 7714，即《文后参考文献著录规则》，规定了中文文献的引用规范，确保了学术信息...
基于Spark的LambdaMART实现.zip
03-14
本主题将深入探讨如何利用Spark实现LambdaMART（Lambda Multiple Additive Regression Trees）算法，这是一种广泛应用于排序任务的集成学习方法。LambdaMART是Machine Learning to Rank（MLTR）中的一个重要模型，...
基于pjsip实现GBT28181协议
11-20
**基于pjsip实现GBT28181协议** PJSIP是一个开源的多媒体通信库，它提供了SIP（会话发起协议）的完整实现，包括VoIP、视频通话、即时消息等多种功能。GBT28181是中国国家标准化管理委员会制定的《公共安全视频监控...
Chinese Std GBT7714 (author-year).zip
03-29
这个压缩包"Chinese Std GBT7714 (author-year).zip"包含了一个Endnote样式文件，即"Chinese Std GBT7714 (author-year).ens"，它专门用于帮助用户在Endnote文献管理软件中按照GB/T 7714标准格式化引用。 GB/T 7714...
GBDT算法详解
星辰的博客
03-04 1万+
基本思想 GBDT的基本结构是决策树组成的森林，学习方式是梯度提升。 具体的讲，GBDT作为集成模型，预测的方式是把所有子树的结果加起来。GBDT通过逐一生成决策子树的方式生成整个森林，生成新子树的过程是利用样本标签值与当前树林预测值之间的残差，构建新的子树。 例如，当前已经生成了3课子树了，则当前的预测值为D(x)=d1(x)+d2()x+d3(x)，此时我们得到的当前的预测值为D(x)效果并不好，与真正的拟合函数f(x)还有一定的差距。GBDT希望的是构建第四棵子树，使当前树林的预测结果D(x)与第四棵
GBDT算法（最简单）
程序猿进化梯
10-19 9158
https://github.com/NLP-LOVE/ML-NLP/blob/master/Machine%20Learning/3.2%20GBDT/3.2%20GBDT.md 1. 解释一下GBDT算法的过程 GBDT(Gradient Boosting Decision Tree)，全名叫梯度提升决策树，使用的是Boosting的思想。 1.1 Boosting思想 Boosting方法训练基分类器时采用串行的方式，各个基分类器之间有依赖。它的基本思路是将基分类器层层叠加，每一层在训练的时候，对前一
梯度提升树（Gradient Boosting Trees）的效率与优化
03-13 493
通过不断的优化和技术创新，相信GBT算法在效率和性能上会有进一步的提升，为解决现实世界中的复杂问题提供更加可靠和高效的解决方案。GBT需要同时维护多棵树的结构和参数，因此会占用大量内存，尤其是在树的深度较大或者树的数量较多的情况下，内存消耗会成为一个严重的问题。随着数据量的增加，GBT的训练时间会显著增加，特别是在处理大规模数据集时，训练时间可能会成倍增长，影响模型的实际应用。利用压缩技术对树的结构和参数进行精简和压缩，减小模型占用的内存空间，降低内存消耗，以应对大规模数据和复杂模型的挑战。
XGBoost：极速梯度提升树的奇迹
程序员光剑
12-26 981
1.背景介绍 梯度提升树(Gradient Boosting Trees, GBT)是一种强大的机器学习算法，它通过构建多个有偏差的决策树来逐步优化模型，从而提高预测准确性。XGBoost(eXtreme Gradient Boosting)是一种极速梯度提升树的实现，它通过对原始GBT算法进行优化和改进，提供了更高效、更准确的模型训练和预测。 XGBoost的核心优势在于其高效的并行计算和内...
GBT算法在拖动滑块辨别人还是机器中的应用
weixin_34174322的博客
12-15 344
1.数据源格式：（x,y,t),第一个值x是x坐标范围是1-250的整数，y是1-10的整数，t是滑块从上一个坐标到下一个坐标的时间差，ok是判断是人操作的，Fail是判断是机器操作的，数据看的出，同一个记录里面的同一个点,即x,y都相同，但是t不同，以此分析，如果同一个点只出现一次，则该点记录为1，如果出现n次，重复次数为m次，则设计该点的值为m/n,如该点在该条记录出现的总次数是5，t不同的次...
Spark2.0机器学习系列之5：GBDT（梯度提升决策树）、GBDT与随机森林差异、参数调试及Scikit代码分析
热门推荐
qq_34531825的博客
08-30 1万+
GBDT概念 与随机森林的差异 Spark2.0中参数调试
Spark排序算法系列之GBTs使用方式介绍
weixin_34375233的博客
02-15 347
01 — 前言 【Spark排序算法系列】主要介绍的是目前推荐系统或者广告点击方面用的比较广的几种算法，和他们在Spark中的应用实现，本篇文章主要介绍GBDT算法，本系列还包括（持续更新）： Spark排序算法系列之LR（逻辑回归） Spark排序算法系列之模型融合（GBDT+LR） Spark排序算法系列之XGBoost Spark...
bagging boosting 和 提升树
m0_47164948的博客
09-12 150
bagging boosting 和 提升树 bagging是通过结合几个模型降低泛化误差，分别训练几个不同的模型，然后让所有的模型表决测试样例的输出。模型平均奏效的原因是不同的模型通常不会在测试集上产生完全相同的误差。从原始样本集中抽取训练集.每轮从原始样本集中使用Bootstraping的方法抽取n个训练样本（在训练集中，有些样本可能被多次抽取到，而有些样本可能一次都没有被抽中）.共进行k轮抽取，得到k个训练集.（k个训练集相互独立） Bagging是并行的学习算法，思想很简单，即每一次从原始数据中根
Chat gbt怎么使用？
03-30
GBT（Gradient Boosting Tree）是一种机器学习算法，通常用于分类和回归问题。在使用GBT之前，需要先收集和处理数据，将其分成训练集和测试集，并进行特征选择和数据清洗。 接下来，可以使用Python中的scikit-learn...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值