1
00:00:17,449 --> 00:00:27,570
大家好！这是第四部分的最后一节课4.6，集成学习法。

2
00:00:27,570 --> 00:00:34,250
在现实生活中，我们做关键决策时，经常会通过

3
00:00:34,250 --> 00:00:35,670
委员会来决定。

4
00:00:35,670 --> 00:00:41,000
选择不同领域的专家，从不同角度看问题，

5
00:00:41,000 --> 00:00:47,870
通过投票的方式做决策，通常会很有效。

6
00:00:48,580 --> 00:00:51,320
机器学习也是一样。

7
00:00:51,320 --> 00:00:56,629
我们通常可以选取一组不同的机器学习方法来提高预测性能。

8
00:00:56,629 --> 00:01:01,629
对同一问题，使用不同的分类器，然后让它们投票

9
00:01:01,629 --> 00:01:06,840
决定对未知测试实例的分类。

10
00:01:06,840 --> 00:01:10,360
弊端之一是这样产生的结果会难以分析。

11
00:01:10,360 --> 00:01:15,990
产生一个可理解的结果的方法已经存在，

12
00:01:15,990 --> 00:01:19,560
但我们这里不讲。

13
00:01:19,560 --> 00:01:23,219
虽然结果难以分析，但是总体性能表现不错。

14
00:01:24,500 --> 00:01:28,289
这是一个较新的机器学习技术。

15
00:01:29,200 --> 00:01:34,950
下面，我们来看四种方法：装袋（bagging）、随机化（randomization）、加强（boosting）和

16
00:01:34,950 --> 00:01:36,509
堆栈（stacking）。

17
00:01:36,509 --> 00:01:40,469
当然，它们都是Weka的功能。

18
00:01:40,469 --> 00:01:45,450
使用bagging时，我们需要几个不同的决策结构，

19
00:01:45,450 --> 00:01:52,110
假设使用J48来创建决策树，我们想创建不同的决策树。

20
00:01:52,119 --> 00:01:57,109
我们需要几个相同大小的独立的训练数据集。

21
00:01:57,109 --> 00:02:02,429
我们来从原始的训练数据集中取样。

22
00:02:02,429 --> 00:02:08,039
事实上，使用bagging，你可以重复取样，

23
00:02:08,039 --> 00:02:15,039
也就是说有时你的样本中会有两个同样的实例。

24
00:02:15,400 --> 00:02:20,040
我们创建几个不同的训练数据集后，再为每个数据集建立不同的模型

25
00:02:20,040 --> 00:02:24,120
（比方说决策树） 使用相同的机器学习方法，或其他

26
00:02:24,120 --> 00:02:25,590
机器学习方法。

27
00:02:25,590 --> 00:02:32,590
然后我们通过投票来决定预测，或者，如果是回归的情况，

28
00:02:32,650 --> 00:02:38,439
我们对所有数值的结果求平均数，而不是投票决定。

29
00:02:38,439 --> 00:02:43,540
这非常适合“不稳定”的学习方法。

30
00:02:43,540 --> 00:02:48,620
不稳定的学习方法指训练数据的微小变化就会带来

31
00:02:48,620 --> 00:02:51,540
模型的巨大变化。

32
00:02:51,540 --> 00:02:53,670
决策树就是个很好的实例。

33
00:02:53,670 --> 00:02:57,040
你可以对训练数据做微小的变动，

34
00:02:57,040 --> 00:03:00,799
继而得到完全不同的决策树。

35
00:03:00,799 --> 00:03:06,969
而Naive Bayes就是稳定的机器学习方法，如果你想想

36
00:03:06,969 --> 00:03:11,409
Naive Bayes的工作原理，就知道训练数据的微小变动不会带来结果的

37
00:03:11,409 --> 00:03:13,799
显著不同。

38
00:03:13,799 --> 00:03:18,450
在Weka中，bagging分类器在meta集合之下。

39
00:03:18,450 --> 00:03:25,450
我们来选择meta，然后Bagging。

40
00:03:27,739 --> 00:03:32,689
我们来选择装袋的大小（ 这里是100%），也就是

41
00:03:32,689 --> 00:03:37,579
从训练数据集中取样得到另一个相同大小的数据集，

42
00:03:37,579 --> 00:03:39,269
即重复取样。

43
00:03:39,269 --> 00:03:45,019
也就是说我们每次取样都得到同样大小的不同数据集，

44
00:03:45,019 --> 00:03:50,159
但是每个数据集都包含重复的训练数据集中的实例。

45
00:03:50,159 --> 00:03:54,890
这里我们可以选择需装袋的分类器，装袋循环次数，

46
00:03:54,890 --> 00:03:58,730
和随机数种子。

47
00:03:58,730 --> 00:04:02,140
这就是装袋法（bagging）。

48
00:04:02,140 --> 00:04:05,140
下面我们来学习“随机森林“ （Random Forest)。

49
00:04:05,140 --> 00:04:09,239
这次，我们不是随机训练数据，而是随机算法。

50
00:04:09,239 --> 00:04:13,519
如何随机算法取决于算法是什么。

51
00:04:13,519 --> 00:04:17,049
当你使用决策树算法时就`叫随机森林。

52
00:04:17,049 --> 00:04:23,220
还记得J48是如何工作的吗？每次选择最好的

53
00:04:23,220 --> 00:04:24,490
属性分裂。

54
00:04:24,490 --> 00:04:30,160
你可以通过不选择最好的属性，而是选择若干较好的属性，

55
00:04:30,160 --> 00:04:33,180
从中随机抽取一个，来随机化这个步骤。

56
00:04:33,180 --> 00:04:35,480
每次都会得到不同的决策树。

57
00:04:35,480 --> 00:04:44,060
总体来说，如果随机选择决策树，并装袋结果，

58
00:04:44,060 --> 00:04:47,110
你会得到较好的准确率。

59
00:04:47,110 --> 00:04:54,110
在Weka中，RandomForest在tree分类器下。

60
00:04:58,500 --> 00:05:01,080
这里有一组参数。

61
00:05:01,080 --> 00:05:06,110
决策树的最大深度（我想0是指无限深度）。

62
00:05:06,110 --> 00:05:07,970
我们将要使用的属性数量。

63
00:05:07,970 --> 00:05:15,810
我们或许会选择4个属性（我们选择最显著的4个属性） 

64
00:05:15,810 --> 00:05:23,560
每次我们对树作决策时，我们从最好的4个属性中选择。

65
00:05:23,560 --> 00:05:29,170
这是决策树的数量，等等。

66
00:05:29,170 --> 00:05:33,190
这就是决策森林。

67
00:05:33,190 --> 00:05:36,590
下面我们来学习另一种算法：加强（boosting）。

68
00:05:36,590 --> 00:05:42,960
加强法是循环算法：新一轮的模型建立在先前模型的分类结果之上。

69
00:05:42,960 --> 00:05:48,220
简单来说，你先创建一个模型，然后找到那些

70
00:05:48,220 --> 00:05:49,880
分类错误的实例。

71
00:05:49,880 --> 00:05:53,960
总有一些不好分类的实例，分类错误的实例。

72
00:05:53,960 --> 00:06:01,060
你在这些实例上加权来为下一轮建立新的模型

73
00:06:01,060 --> 00:06:04,220
创建训练数据集。

74
00:06:04,220 --> 00:06:10,100
这样，新模型对于被先前模型分类错误的实例充当

75
00:06:10,100 --> 00:06:13,650
“专家”的角色。

76
00:06:13,650 --> 00:06:17,960
直观的理由是在现实生活中委员会里，委员们应该是

77
00:06:17,960 --> 00:06:24,960
以关注问题的不同方面来互相弥补。

78
00:06:25,490 --> 00:06:30,900
最后，我们通过投票来博取众长，其实我们根据模型的效果来

79
00:06:30,900 --> 00:06:33,280
加权模型。

80
00:06:33,280 --> 00:06:41,440
在Weka中，有个非常好的叫做AdaBoostM1的方案，它是标准的

81
00:06:41,440 --> 00:06:47,260
非常好的分类器 （ 经常得到很棒的结果）。

82
00:06:47,980 --> 00:06:54,260
AdaBoostM1也有若干参数，特别是循环次数参数。

83
00:06:55,800 --> 00:07:00,060
最后一个集成学习法叫做堆栈（stacking）。

84
00:07:00,060 --> 00:07:04,800
我们将使用基础的方法，就像之前我们讲过的方法一样。

85
00:07:04,800 --> 00:07:10,050
我们要使用一种元学习法（meta-learner）来组合它们的预测结果，

86
00:07:10,050 --> 00:07:13,020
而不是靠投票决定。

87
00:07:14,140 --> 00:07:19,500
我们把基础方法叫0层模型，元学习法是1层模型。

88
00:07:19,500 --> 00:07:24,780
基础方法所做的预测就是元学习法的输入。

89
00:07:24,780 --> 00:07:28,990
通常我们使用不同的机器学习法作为基础方法，

90
00:07:28,990 --> 00:07:32,300
就像使用擅长不同领域的专家。

91
00:07:32,300 --> 00:07:37,430
在你生成数据来训练1层模型时，要非常小心。

92
00:07:37,430 --> 00:07:43,080
这里涉及到许多交叉验证，我现在不讲这点。

93
00:07:43,080 --> 00:07:52,090
在Weka中，有一个元分类器叫Stacking，另一个 叫StackingC 

94
00:07:52,090 --> 00:07:55,950
它是一个更有效的堆栈分类器。

95
00:07:55,950 --> 00:08:06,400
这就是Stacking。你可以选择不同的元分类器，以及折的数量。

96
00:08:07,920 --> 00:08:13,400
我们可以选择不同的分类器，不同的0层分类器和元分类器。

97
00:08:20,270 --> 00:08:25,990
如果要创建多个0层模型，你需要设置元分类器为

98
00:08:25,990 --> 00:08:28,190
0层模型。

99
00:08:28,190 --> 00:08:34,579
有点复杂，要在Weka中通过些步骤才能完成。

100
00:08:34,579 --> 00:08:35,190
好了。

101
00:08:35,190 --> 00:08:40,430
我们已经讲了通过组合多种模型来创建一个集成模型，

102
00:08:40,430 --> 00:08:43,940
就像人类的委员会一样。

103
00:08:44,540 --> 00:08:48,420
预测差异是有帮助的，特别是当学习方法不稳定的时候，

104
00:08:49,980 --> 00:08:52,100
而且我们可以通过不同的方式来制造差异。

105
00:08:52,100 --> 00:08:56,630
在bagging中，我们通过从训练数据集中重新取样来制造差异。

106
00:08:56,630 --> 00:09:02,130
在 random forests中，我们通过为决策树选择不同的分支

107
00:09:02,130 --> 00:09:03,570
来制造差异。

108
00:09:03,570 --> 00:09:09,310
在boosting中，我们通过关注现有模型的错误来制造差异。

109
00:09:09,310 --> 00:09:14,130
在stacking中，我们使用另一个学习方法来组合输出不同学习方法的结果，

110
00:09:14,130 --> 00:09:18,150
而不单单是通过投票决定。

111
00:09:18,150 --> 00:09:24,280
课本中有一章是关于集成学习法的（这真是一大主题）。

112
00:09:24,280 --> 00:09:29,560
你还需要做练习，请在我们开始讲解

113
00:09:29,560 --> 00:09:31,940
最后一部分之前完成。

114
00:09:31,940 --> 00:09:36,680
我们将要学习把这些知识融合在一起，宏观来看机器学习

115
00:09:36,680 --> 00:09:39,180
过程。

116
00:09:39,180 --> 00:09:40,370
下次见。

117
00:09:40,370 --> 00:09:41,820
再见！