常见算法（下）-朴素贝叶斯，SVM

朴素贝叶斯的公式：

先来看几组定义，然后再慢慢进入贝叶斯。 

几种概率的定义：

先验概率：堵车发生的概率是多少？早上出门，我不知道有没有交通事故，也不知道车辆多不多，堵车的概率是多少？

条件概率：P(堵车|交通事故) 在交通事故发生的情况下，堵车的概率是多少？

后验概率：P(交通事故|堵车) 在堵车发生的情况下，原因是交通事故的概率是多少？

这几个概念，先和后，其实是指事情发生的先后，这里的事情是指，我们将要进行概率计算的事情。

先，先预测一把，我不知道会不会发生这个事，先预测一个概率。

后，事情发生之后，去预测一下造成这个事情的某个原因的概率是多少。也可以说，结果发生，是某个原因造成的概率是多少。

接下来就开始讲鼎鼎有名的贝叶斯了：

今天前方发生交通事故，并且堵车的概率是多少？

1. 发生交通事故 （是有一定概率的）
2. 发生交通事故后，还需要堵车  （也是有一定概率的）

有可能，压根没有交通事故，即使有交通事故，没有造成堵车

这个情景，是我早上刚刚起来，盲猜可能会发生交通事故，而且还堵车的概率。这里有几种情况：1）首先是题目的这个情况，发生交通事故，而且还堵车；2）可能不会发生交通事故；3）发生了交通事故，但是没有堵车， 基本就这三种情况，也就是说这三个事情的概率，加起来等于1。所以说，“发生交通事故”，是有一定的概率；“发生交通事故，而且堵车”，也是有一定的概率。

接下来，需要稍微动一下脑子，我们发现：

“发生交通事故，并且堵车”这个事情，和“堵车，因为发生交通事故”，说的是一个意思，所以它们发生的概率相同。即：

P(交通事故) * P(堵车|交通事故) = P(堵车)*P(交通事故|堵车)

到这里，大名鼎鼎的贝叶斯已经出现了，只要等式两边同时除于P(交通事故)，就能得到朴素贝叶斯的雏形。

P(堵车|交通事故) = P(堵车)*P(交通事故|堵车)/ P(交通事故)

接下来，引入特征和类别的概念，

结合上面的例子，

交通事故： 特征

堵车： 类别

带入上边等式，就得到朴素贝叶斯。

什么是特征，什么是类别？

特征，相当于因子，相当于x；

类别是y，是目的，是响应，是label, 是target.

类似于下面这个表，”嫁与否“ 是类别，其它都是特征。

接下来，有个问题：

两件事情同时发生的概率不是应该等于两者独立的概率乘积吗？

答：两件事情要独立才可以，也就是两件事情不能相关。

今天前方发生交通事故，并且堵车的概率 P(交通事故，堵车)= P(交通事故) * P(堵车) 不对，因为按照常识，交通事故和堵车显然是有关系的。

关于这个问题，老师课上举了好几个例子，抢银行，我有钱等等。

条件概率其实是容易理解的，也基本不大需要自己去推演公式。了解即可。

---

SVM

---

1.   SVM最基本的应用是分类，监督学习
2.  求解最优的分类面，然后用于分类。
3. 对于SVM，存在一个分类面，两个点集到此平面的最小距离最大，两个点集中的边缘点到此平面的距离最大。

用大白话来讲，就是找一根线，或一个平面，甚至是一个超级曲面，把两组数尽量的分开，也就是分的越开越好。

也就是这条线，或者这个平面，离得最近得点都比较远。

# SVM
from sklearn.svm import SVC
# (1) 训练
SVM_model= SVC()
start=time.time()
SVM_model.fit(train_feature_normal,train_target)
end=time.time()
print('SVM用时：{}'.format(end-start))
# （2）测试
SVM_predict= SVM_model.predict(test_feature_normal)
# 损失函数，类似于错误率是多少
print('SVM的损失函数值MSE:')
print(metrics.mean_squared_error(test_target,SVM_predict))
#可以通过下面求正确率，也就是打分，打分有打分的函数：score
print('SVM打分：')
print(SVM_model.score(test_feature_normal,test_target))
print('------------------------')

运行结果：

逻辑回归用时：0.012961864471435547
逻辑回归的损失函数值MSE:
0.02631578947368421
逻辑回归打分：
0.9736842105263158
------------------------
决策树用时：0.007003068923950195
决策树的损失函数值MSE:
0.11403508771929824
决策树打分：
0.8859649122807017
------------------------
随机森林用时：0.19504046440124512
随机森林的损失函数值MSE:
0.06140350877192982
随机森林打分：
0.9385964912280702
------------------------
朴素贝叶斯用时：0.0009586811065673828
朴素贝叶斯的损失函数值MSE:
0.07894736842105263
朴素贝叶斯打分：
0.9210526315789473
------------------------
SVM用时：0.003990888595581055
SVM的损失函数值MSE:
0.02631578947368421
SVM打分：
0.9736842105263158
------------------------

发现SVM的正确率是最高的。

---

朴素贝叶斯Python实现

---

在进行python实战时，下面的知识有必要了解一下：

1. from sklearn.naive_bayes import GaussianNB
2. from sklearn.naive_bayes import MultinomialNB
3. from sklearn.naive_bayes import BernoulliNB
4. GaussianNB就是先验为高斯(正态)分布的朴素贝叶斯，MultinomialNB就是先验为多项式分布的朴素贝叶斯，而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。
5. 这三个类适用的分类场景各不相同，一般来说，如果样本特征的分布大部分是连续值，使用GaussianNB会比较好。如果如果样本特征的分大部分是多元离散值，使用MultinomialNB比较合适。而如果样本特征是二元离散值或者很稀疏的多元离散值，应该使用BernoulliNB。

 伯努利使用于二元离散，即0和1的情况。

# 朴素贝叶斯
from sklearn.naive_bayes import GaussianNB
# (1) 训练
naive_byes_model= GaussianNB()
start=time.time()
naive_byes_model.fit(train_feature_normal,train_target)
end=time.time()
print('朴素贝叶斯用时：{}'.format(end-start))
# （2）测试
naive_byes_predict= naive_byes_model.predict(test_feature_normal)
# 损失函数，类似于错误率是多少
print('朴素贝叶斯的损失函数值MSE:')
print(metrics.mean_squared_error(test_target,naive_byes_predict))
#可以通过下面求正确率，也就是打分，打分有打分的函数：score
print('朴素贝叶斯打分：')
print(naive_byes_model.score(test_feature_normal,test_target))

逻辑回归，决策树，随机森林，朴素贝叶斯的运行结果对比：

逻辑回归用时：0.01094198226928711
逻辑回归的损失函数值MSE:
0.07894736842105263
逻辑回归打分：
0.9210526315789473
------------------------
决策树用时：0.005102872848510742
决策树的损失函数值MSE:
0.17543859649122806
决策树打分：
0.8245614035087719
------------------------
随机森林用时：0.18603968620300293
随机森林的损失函数值MSE:
0.11403508771929824
随机森林打分：
0.8859649122807017
------------------------
朴素贝叶斯用时：0.0009047985076904297
朴素贝叶斯的损失函数值MSE:
0.2543859649122807
朴素贝叶斯打分：
0.7456140350877193

---

KNN-最邻近分类算法KNN（K-Nearest Neighbor）

---

近朱者赤，近墨者黑，即由你的邻居来推断出你的类别

为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，根据少数服从多数的投票法则，将未知样本与K个最邻近样本中所属类别占比较多的归为一类.

 

K 是根据个人的经验来进行选择的。

在上面的例子中，有两组已知数，红圈和蓝色三角形，现在来了一个新的数，我想知道它应该归入哪一类？

取K等于3， 画一个圆圈，这个圆圈中，有两个三角一个红圈，所以新的伙伴应该归入蓝色三角。

 

但是当K=5时，结果又不一样。

距离怎么算？

K 怎么确定？

通过交叉验证（将样本数据按照一定比例，拆分出训练用的数据和验证用的数据，比如6：4拆分出部分训练数据和验证数据），从选取一个较小的K值开始，不断增加K的值，然后计算验证集合的 mean_square_error ，最终找到一个比较合适的K值。

代码如下：

# KNN
from sklearn.neighbors import KNeighborsClassifier
# (1) 训练
KNN_model= KNeighborsClassifier(n_neighbors=5)
start=time.time()
KNN_model.fit(train_feature_normal,train_target)
end=time.time()
print('KNN用时：{}'.format(end-start))
# （2）测试
KNN_predict= KNN_model.predict(test_feature_normal)
# 损失函数，类似于错误率是多少
print('KNN的损失函数值MSE:')
print(metrics.mean_squared_error(test_target,KNN_predict))
#可以通过下面求正确率，也就是打分，打分有打分的函数：score
print('KNN打分：')
print(KNN_model.score(test_feature_normal,test_target))
print('------------------------')

几个算法的运行结果：

逻辑回归用时：0.00997304916381836
逻辑回归的损失函数值MSE:
0.05263157894736842
逻辑回归打分：
0.9473684210526315
------------------------
决策树用时：0.005958080291748047
决策树的损失函数值MSE:
0.08771929824561403
决策树打分：
0.9122807017543859
------------------------
随机森林用时：0.16757416725158691
随机森林的损失函数值MSE:
0.05263157894736842
随机森林打分：
0.9473684210526315
------------------------
朴素贝叶斯用时：0.0009517669677734375
朴素贝叶斯的损失函数值MSE:
0.08771929824561403
朴素贝叶斯打分：
0.9122807017543859
------------------------
SVM用时：0.0029685497283935547
SVM的损失函数值MSE:
0.03508771929824561
SVM打分：
0.9649122807017544
------------------------
KNN用时：0.0010898113250732422
KNN的损失函数值MSE:
0.07017543859649122
KNN打分：
0.9298245614035088
------------------------

KNN不是很稳定，忽高忽低，那么可以用For循环找出正确率最高的值，代码：

# 找出最高的正确率
max_score=0
optimal_k=0
for i in range(1,21):
    KNN_model = KNeighborsClassifier(n_neighbors=i)
    KNN_model.fit(train_feature_normal, train_target)
    score=KNN_model.score(test_feature_normal, test_target)
    print('KNN, K={},score={}'.format(i,score))
    if score >max_score:
        max_score=score
        optimal_k=i
print('optimal KNN, K={},score={}'.format(optimal_k,max_score))

结果：

KNN用时：0.0
KNN, K=1,score=0.9385964912280702
KNN, K=2,score=0.8947368421052632
KNN, K=3,score=0.9122807017543859
KNN, K=4,score=0.9122807017543859
KNN, K=5,score=0.9298245614035088
KNN, K=6,score=0.9210526315789473
KNN, K=7,score=0.9298245614035088
KNN, K=8,score=0.9298245614035088
KNN, K=9,score=0.9385964912280702
KNN, K=10,score=0.9298245614035088
KNN, K=11,score=0.9385964912280702
KNN, K=12,score=0.9210526315789473
KNN, K=13,score=0.9210526315789473
KNN, K=14,score=0.9210526315789473
KNN, K=15,score=0.9210526315789473
KNN, K=16,score=0.9210526315789473
KNN, K=17,score=0.9210526315789473
KNN, K=18,score=0.9210526315789473
KNN, K=19,score=0.9210526315789473
KNN, K=20,score=0.9210526315789473
optimal KNN, K=1,score=0.9385964912280702

---

交叉验证

---

1. 之前我们的做法：
2. 整个数据集分成两部分，一部分用于训练，一部分用于验证，训练集（training set）和测试集（test set）
3. 训练集和测试集的划分方法不够好，可能不能找到最好的模型与参数
4. 训练的数据量越大，训练出来的模型通常越好

 把数据集分为10份，给10次机会，每一次机会变换一个测试集，从D1,D2,...D10。

总结如下：

1. 将所有数据集分成5份
2. 不重复地每次取其中1份做测试集，其他4做训练集训练模型，之后计算该模型在测试集上的MSE
3. 将5次的MSE取平均得到最后的MSE

实际上，就是DoE的方法，每次变换一个因子进行验证。这种情况，对于数据量不是很大的时候，尤其如此。正像老师课上举的例子，只有100份试卷，如果拿出20%用于考试，留给学生的只有80%， 这80%的试题中，有20%的题型可能是学生接触不到的，因为这些题型是在20%的用于考试的题目里面，那么即使是好学生，只做80%的题目，未必能考出好成绩，这就错过了好学生。交叉验证的目的就是不要错过好学生。考的不好，有5次机会，4次训练，一次测试，取平均值。

方法一： for循环

第一步：划分数据

# 理解交叉验证原理
#第一种方法
# Kfold帮助划分数据
from sklearn.model_selection import KFold

#把数据切分5份
kf= KFold(n_splits=5)
# 下面的语句，kf会返回两套值：训练集和测试集
# train_index, test_index是训练集和测试集的行号
# 这里的feature是前面
for train_index,test_index in kf.split(feature):
    print('-------------------')
    print('train index:')
    print(train_index)
    print('test index:')
    print(test_index)
    # 每次都会告诉你一个训练集和测试集的划分

# 提取数据，用loc
   train_feature= feature.loc(train_index)
   train_target=target.loc(train_target)
   test_feature=feature.loc(test_index)
   test_target= target.loc(test_index)

得到如下的数据划分：

第一套：

总共568行，每一行是一个训练数据。

train index:
[114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
.....568
test index:
[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113]

第二套：

train index:
[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113 228 229 230 231 232 233 234 235 236 237 238 239
 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257
 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
...568
test index:
[114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
 222 223 224 225 226 227]

第三套：

train index:
[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
 216 217 218 219 220 221 222 223 224 225 226 227 342 343 344 345 346 347
 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
。。。568
test index:
[228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
 336 337 338 339 340 341]

第四套：

train index:
[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
。。。568
test index:
[342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
 450 451 452 453 454 455]

第五套

train index:
[  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17
  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35
  36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51  52  53
  54  55  56  57  58  59  60  61  62  63  64  65  66  67  68  69  70  71
  72  73  74  75  76  77  78  79  80  81  82  83  84  85  86  87  88  89
  90  91  92  93  94  95  96  97  98  99 100 101 102 103 104 105 106 107
 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
 450 451 452 453 454 455]
test index:
[456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509
 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
 564 565 566 567 568]

第二部：归一化

  #归一化                                                     
  #训练数据和测试数据都需要归一化                                         
  train_feature_normal= scaler.fit_transform(train_feature)
  test_feature_normal= scaler.fit_transform(test_feature)  

第三步：模型训练

    #模型训练                                  
    svm_model=SVC()                        
    svm_model.fit(train_feature_normal,trai
    score=svm_model.score(test_feature_norm
    print('SVM打分：{}'.format(score))        
    sum_score= sum_score+score             
# 五组打分取平均值                                 
print('平均分：{}'.format(sum_score/5))        
                                           

运行结果：

平均分：0.9542462350566682

方法二：直接调用cross_validate函数

# 跟第一种方法是一样的                          
from sklearn.model_selection import cr
#  SVM +交叉验证                          
SVM_model= SVC()                      
scaler_svm= MinMaxScaler()            
feature_normal= scaler_svm.fit_transfo
score=cross_validate(SVM_model, featur
print('交叉验证打分：{}'.format(score))      
#计算分数的平均值                             
print(score['test_score'].mean())     
                                      

交叉验证打分：{'fit_time': array([0.00397539, 0.00491786, 0.00498652, 0.00498676, 0.00495338]), 'score_time': array([0.00200605, 0.00207782, 0.00299191, 0.00299168, 0.00203753]), 'test_score': array([0.96491228, 0.96491228, 0.99122807, 0.96491228, 0.98230088])}
0.9736531594472908