spark机器学习之常见的分类算法应用

今天简单记录下mllib中常见的分类算法，在分类的子文件夹下主要有三类分类算法：logistic回归模型、贝叶斯模型、SVM模型。

logistic回归模型

首先需要认清的是逻辑斯蒂回归并非回归模型，和上节介绍的线性回归不一样，它是属于分类模型，虽然和线性回归功能上不一样，但是形式上和线性回归还是很相似的，不同点在于通过添加logistic映射函数使得原始的线性回归方程式变成了可用于分类的模型。应该来说logistic回归模型是分类算法里面最简单的，实际中也是最容易最先被尝试的一种方法。

关于logistic回归的详细原理，以前的文章一件详细介绍过了，对原理不明白的可以参考：

机器学习之logistic回归与分类

本节旨在记录spark里面的应用方法。在mllib里面，logistic模型的创建很简单，工具箱已经封装好了，在2.11版本中，主要有两种，一直是SGD训练的模型类：LogisticRegressionWithSGD，一直是LBFGS，拟牛顿法，这个方法原理比较高深，显著的特点是优化速度更快，更准，在面试的时候可能会问到，相应的类就是LogisticRegressionWithLBFGS。

• 数据准备

不管是分类还是回归，mllib里面多数是以一种LabeledPoint的数据格式封装每一个训练样本，这个结构在前面仔细介绍过。里面的结构就是（label，feature）的格式，其中feature又是vector的格式，以后后续的所有分类模型，基本都是这种结构。

训练数据采用mllib的example自带的，样子如下：

0 128:51 129:159 130:253 131:159 132:50 155:48 156:238 157:252 158:252 159:252 160:237 182:54 183:227 184:253 185:252 186:239 187:233 188:252 189:57 190:6 208:10 209:60 210:224 211:252 212:253 213:252 214:202 215:84 216:252 217:253 218:122 236:163 237:252 238:252 239:252 240:253 241:252 242:252 243:96 244:189 245:253 246:167 263:51 264:238 265:253 266:253 267:190 268:114 269:253 270:228 271:47 272:79 273:255 274:168 290:48 291:238 292:252 293:252 294:179 295:12 296:75 297:121 298:21 301:253 302:243 303:50 317:38 318:165 319:253 320:233 321:208 322:84 329:253 330:252 331:165 344:7 345:178 346:252 347:240 348:71 349:19 350:28 357:253 358:252 359:195 372:57 373:252 374:252 375:63 385:253 386:252 387:195 400:198 401:253 402:190 413:255 414:253 415:196 427:76 428:246 429:252 430:112 441:253 442:252 443:148 455:85 456:252 457:230 458:25 467:7 468:135 469:253 470:186 471:12 483:85 484:252 485:223 494:7 495:131 496:252 497:225 498:71 511:85 512:252 513:145 521:48 522:165 523:252 524:173 539:86 540:253 541:225 548:114 549:238 550:253 551:162 567:85 568:252 569:249 570:146 571:48 572:29 573:85 574:178 575:225 576:253 577:223 578:167 579:56 595:85 596:252 597:252 598:252 599:229 600:215 601:252 602:252 603:252 604:196 605:130 623:28 624:199 625:252 626:252 627:253 628:252 629:252 630:233 631:145 652:25 653:128 654:252 655:253 656:252 657:141 658:37
1 159:124 160:253 161:255 162:63 186:96 187:244 188:251 189:253 190:62 214:127 215:251 216:251 217:253 218:62 241:68 242:236 243:251 244:211 245:31 246:8 268:60 269:228 270:251 271:251 272:94 296:155 297:253 298:253 299:189 323:20 324:253 325:251 326:235 327:66 350:32 351:205 352:253 353:251 354:126 378:104 379:251 380:253 381:184 382:15 405:80 406:240 407:251 408:193 409:23 432:32 433:253 434:253 435:253 436:159 460:151 461:251 462:251 463:251 464:39 487:48 488:221 489:251 490:251 491:172 515:234 516:251 517:251 518:196 519:12 543:253 544:251 545:251 546:89 570:159 571:255 572:253 573:253 574:31 597:48 598:228 599:253 600:247 601:140 602:8 625:64 626:251 627:253 628:220 653:64 654:251 655:253 656:220 681:24 682:193 683:253 684:220
1 125:145 126:255 127:211 128:31 152:32 153:237 154:253 155:252 156:71 180:11 181:175 182:253 183:252 184:71 209:144 210:253 211:252 212:71 236:16 237:191 238:253 239:252 240:71 264:26 265:221 266:253 267:252 268:124 269:31 293:125 294:253 295:252 296:252 297:108 322:253 323:252 324:252 325:108 350:255 351:253 352:253 353:108 378:253 379:252 380:252 381:108 406:253 407:252 408:252 409:108 434:253 435:252 436:252 437:108 462:255 463:253 464:253 465:170 490:253 491:252 492:252 493:252 494:42 518:149 519:252 520:252 521:252 522:144 546:109 547:252 548:252 549:252 550:144 575:218 576:253 577:253 578:255 579:35 603:175 604:252 605:252 606:253 607:35 631:73 632:252 633:252 634:253 635:35 659:31 660:211 661:252 662:253 663:35
1 153:5 154:63 155:197 181:20 182:254 183:230 184:24 209:20 210:254 211:254 212:48 237:20 238:254 239:255 240:48 265:20 266:254 267:254 268:57 293:20 294:254 295:254 296:108 321:16 322:239 323:254 324:143 350:178 351:254 352:143 378:178 379:254 380:143 406:178 407:254 408:162 434:178 435:254 436:240 462:113 463:254 464:240 490:83 491:254 492:245 493:31 518:79 519:254 520:246 521:38 547:214 548:254 549:150 575:144 576:241 577:8 603:144 604:240 605:2 631:144 632:254 633:82 659:230 660:247 661:40 687:168 688:209 689:31
1 152:1 153:168 154:242 155:28 180:10 181:228 182:254 183:100 209:190 210:254 211:122 237:83 238:254 239:162 265:29 266:254 267:248 268:25 293:29 294:255 295:254 296:103 321:29 322:254 323:254 324:109 349:29 350:254 351:254 352:109 377:29 378:254 379:254 380:109 405:29 406:255 407:254 408:109 433:29 434:254 435:254 436:109 461:29 462:254 463:254 464:63 489:29 490:254 491:254 492:28 517:29 518:254 519:254 520:28 545:29 546:254 547:254 548:35 573:29 574:254 575:254 576:109 601:6 602:212 603:254 604:109 630:203 631:254 632:178 658:155 659:254 660:190 686:32 687:199 688:104
0 130:64 131:253 132:255 133:63 157:96 158:205 159:251 160:253 161:205 162:111 163:4 184:96 185:189 186:251 187:251 188:253 189:251 190:251 191:31 209:16 210:64 211:223 212:244 213:251 214:251 215:211 216:213 217:251 218:251 219:31 236:80 237:181 238:251 239:253 240:251 241:251 242:251 243:94 244:96 245:251 246:251 247:31 263:92 264:253 265:253 266:253 267:255 268:253 269:253 270:253 271:95 272:96 273:253 274:253 275:31 290:92 291:236 292:251 293:243 294:220 295:233 296:251 297:251 298:243 299:82 300:96 301:251 302:251 303:31 317:80 318:253 319:251 320:251 321:188 323:96 324:251 325:251 326:109 328:96 329:251 330:251 331:31 344:96 345:240 346:253 347:243 348:188 349:42 351:96 352:204 353:109 354:4 356:12 357:197 358:251 359:31 372:221 373:251 374:253 375:121 379:36 380:23 385:190 386:251 387:31 399:48 400:234 401:253 413:191 414:253 415:31 426:44 427:221 428:251 429:251 440:12 441:197 442:251 443:31 454:190 455:251 456:251 457:251 468:96 469:251 470:251 471:31 482:190 483:251 484:251 485:113 495:40 496:234 497:251 498:219 499:23 510:190 511:251 512:251 513:94 522:40 523:217 524:253 525:231 526:47 538:191 539:253 540:253 541:253 548:12 549:174 550:253 551:253 552:219 553:39 566:67 567:236 568:251 569:251 570:191 571:190 572:111 573:72 574:190 575:191 576:197 577:251 578:243 579:121 580:39 595:63 596:236 597:251 598:253 599:251 600:251 601:251 602:251 603:253 604:251 605:188 606:94 624:27 625:129 626:253 627:251 628:251 629:251 630:251 631:229 632:168 633:15 654:95 655:212 656:251 657:211 658:94 659:59
1 159:121 160:254 161:136 186:13 187:230 188:253 189:248 190:99 213:4 214:118 215:253 216:253 217:225 218:42 241:61 242:253 243:253 244:253 245:74 268:32 269:206 270:253 271:253 272:186 273:9 296:211 297:253 298:253 299:239 300:69 324:254 325:253 326:253 327:133 351:142 352:255 353:253 354:186 355:8 378:149 379:229 380:254 381:207 382:21 405:54 406:229 407:253 408:254 409:105 433:152 434:254 435:254 436:213 437:26 460:112 461:251 462:253 463:253 464:26 487:29 488:212 489:253 490:250 491:149 514:36 515:214 516:253 517:253 518:137 542:75 543:253 544:253 545:253 546:59 570:93 571:253 572:253 573:189 574:17 598:224 599:253 600:253 601:84 625:43 626:235 627:253 628:126 629:1 653:99 654:248 655:253 656:119 682:225 683:235 684:49
1 100:166 101:222 102:55 128:197 129:254 130:218 131:5 155:29 156:249 157:254 158:254 159:9 183:45 184:254 185:254 186:174 187:2 210:4 211:164 212:254 213:254 214:85 238:146 239:254 240:254 241:254 242:85 265:101 266:245 267:254 268:254 269:254 270:85 292:97 293:248 294:254 295:204 296:254 297:254 298:85 315:12 316:59 317:98 318:151 319:237 320:254 321:254 322:109 323:35 324:254 325:254 326:85 343:41 344:216 345:254 346:254 347:239 348:153 349:37 350:4 351:32 352:254 353:254 354:85 372:7 373:44 374:44 375:30 379:32 380:254 381:254 382:96 407:19 408:230 409:254 410:174 436:197 437:254 438:110 464:197 465:254 466:85 492:197 493:253 494:63 515:37 516:54 517:54 518:45 519:26 520:84 521:221 522:84 523:21 524:31 525:162 526:78 540:6 541:41 542:141 543:244 544:254 545:254 546:248 547:236 548:254 549:254 550:254 551:233 552:239 553:254 554:138 567:23 568:167 569:254 570:254 571:254 572:254 573:229 574:228 575:185 576:138 577:138 578:138 579:138 580:138 581:138 582:44 595:113 596:254 597:254 598:254 599:179 600:64 601:5 623:32 624:209 625:183 626:97
...

这是一种稀疏编码的训练样本，前面也有介绍。第一个数为标签，后面为特征对应的维度与数值。

• 开始训练

数据读进来需要进行简单的分隔处理，然后直接调用模型。以SGD的更新方式为例，代码如下：

// 倒入对应的包
import org.apache.spark.mllib.util.MLUtils
import org.apache.spark.mllib.classification.{LogisticRegressionModel, LogisticRegressionWithLBFGS,LogisticRegressionWithSGD}
import org.apache.spark.mllib.evaluation.MulticlassMetrics
import org.apache.spark.mllib.regression.LabeledPoint

// 预处理数据
val data = MLUtils.loadLibSVMFile(sc, "/opt/spark-2.3.1-bin-hadoop2.7/data/mllib/sample_libsvm_data.txt")
// Split data into training (60%) and test (40%).
val splits = data.randomSplit(Array(0.6, 0.4), seed = 11L)
val training = splits(0).cache()
val test = splits(1)

// 训练模型，迭代次数50次
val model = LogisticRegressionWithSGD.train(training,50)

// 测试集上测试准确率
val predictionAndLabels = test.map { case LabeledPoint(label, features) =>
      val prediction = model.predict(features)
      (prediction, label)
    }
    
val accuracy = predictionAndLabels.filter(x => x._1 == x._2).count()*1.0/predictionAndLabels.count()
println(s"Accuracy = $accuracy")

结果就是：

>>> Accuracy = 0.9767441860465116

几个函数需要注意：

• randomSplit 这个函数挺有用的，将数据集随机按指定比例分割成训练集与测试集，这个会经常用到；
• model.predict(features)，前面说过，模型预测的时候只需要features，得到的就是预测结构。
• 想看一下各个特征维度的logistic权重怎么看呢：model.weights

scala> model.weights
res7: org.apache.spark.mllib.linalg.Vector = 
[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,
0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.008776754507644561,
0.0027188989504401237,0.00519815438872529,0.007943822969944989,0.009628396498823659,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,-0.0011314466500138571,
-7.360649927204884E-4,0.0016618512746495624,0.0012966429034029882,8.118290701593341E-4,9.222328704041768E-4,4.306298324898361E-4,
3.090345771224447E-4,3.3786173
...

这个权重可以看出来，值为0或者很小的数对应的特征维度基本对预测结果影响不大，这也给了我们另外一个用途，在某些时候可以使用这些权重的大小来衡量某些维度的重要性，也就是特征选择的问题。关于特征选择的问题，以后会再介绍到，很多方法都可以干这件事。

贝叶斯模型

贝叶斯模型是一种基于概率的分类模型，以著名的贝叶斯公式为基础，通过先验概率计算后验概率的一种方法。关于贝叶斯的理论部分，曾经也分享过一篇文章，自认为介绍的非常详细，连接如下：

机器学习之实战朴素贝叶斯算法

但从spark的mllib应用层面，接口非常简单，mllib封装的API确实很好，用法几乎和logisitc一模一样，换个名称即可用。

当然第一步要倒入贝叶斯对应的包，所属的范围依然是org.apache.spark.mllib.classification包里面，导入：

import org.apache.spark.mllib.classification.{NaiveBayes, NaiveBayesModel}

用法没什么两样，记住模型调用的名称：NaiveBayes。一个例子如下：

//同logistic模型，省略数据加载与处理
...

val model = NaiveBayes.train(training, lambda = 1.0, modelType = "multinomial")
val predictionAndLabel = test.map(p => (model.predict(p.features), p.label))
val accuracy = 1.0 * predictionAndLabel.filter(x => x._1 == x._2).count() / test.count()
println(s"Accuracy = $accuracy")
...

一个结果：

>>> Accuracy: Double = 0.9767441860465116

SVM模型

一个经典的不能再经典的模型：SVM。SVM之所以经典，一方面因为再传统机器学习领域其效果已经非常的好了，一方面，其数学理论完备优美，是每个从事机器学习必须掌握的模型。然而，我相信，很多人其实也就看了看基本的推论与结论，至于为什么其实并没有过多的研究。如果你自己手写过SVM的实现代码，相信认识会更加深。

关于SVM的理论，同样我以前也写过系列的文章，从基础原理到完全手写代码实现到应用，感兴趣的可以参考下面的链接跟着一步步实现看看：

解密SVM系列（一）：关于拉格朗日乘子法和KKT条件

spark中，SVM也是位于分类包里面，目前的mllib的分类包里面，就存在这样几个分类模型，当然后面还有决策树等模型，这是在树模型的包里面，后续再说。

使用SVM模型同前面的贝叶斯模型基本无差别， 导入对应的包即可。

import org.apache.spark.mllib.classification.{SVMModel, SVMWithSGD}

SVM的主函数是SVMWithSGD，可以看到分类模型基本都有SGD这一优化方法。部分示例如下：

//同logistic模型，省略数据加载与处理
...

val model = SVMWithSGD.train(training, 50)
val predictionAndLabel = test.map(p => (model.predict(p.features), p.label))
val accuracy = 1.0 * predictionAndLabel.filter(x => x._1 == x._2).count() / test.count()
println(s"Accuracy = $accuracy")
...

>>> Accuracy: Double = 0.9767441860465116

什么都没变，函数名变一下，参数形式变一下。理解了原理，在应用层面来看是非常容易的。

总结

spark里面的这几类分类模型总体来说应用还是很简单的，重点是搞清楚对应的包，准备对应的数据结构，然后直接调用模型就ok了，达到能用的状态基本就是这。当然作为算法工程师，不能仅限于此，内部的原理才是我们需要好好研究的。毕竟这个时候，机器学习已经火了好多年了，仅仅会使用模型或者调参已经不足以生存下去了，有时候问题必须深入到原理层面才能得到解决。

---

关注公号【AInewworld】，第一时间获取精彩内容