1
00:00:16,460 --> 00:00:20,980
大家好！欢迎再次来到新西兰。

2
00:00:20,980 --> 00:00:27,410
上次课，第五部分第一课，我们知道了Weka只能帮助你

3
00:00:27,410 --> 00:00:33,370
完成数据挖掘过程中的一小部分工作，技术部分，也许是最容易的部分。

4
00:00:33,370 --> 00:00:38,690
这节课，我们会了解到即使这部分也有

5
00:00:38,690 --> 00:00:40,470
许多缺陷和失误。

6
00:00:41,860 --> 00:00:43,149
让我给你解释这些问题。

7
00:00:43,149 --> 00:00:48,840
“缺陷”是隐藏的或者没有料到的危险和困难，

8
00:00:48,840 --> 00:00:51,059
这在机器学习的领域有很多。

9
00:00:51,059 --> 00:00:57,690
“失误”是一种愚蠢的丢脸的行为，使用数据时，

10
00:00:57,690 --> 00:01:01,870
很容易做出这样的事情。

11
00:01:01,870 --> 00:01:04,710
首要的教训是你应该持有怀疑的态度。

12
00:01:04,710 --> 00:01:08,860
在数据挖掘领域，作弊很容易。

13
00:01:08,860 --> 00:01:14,659
不论你是有意作弊还是无意作弊，你的结果的显着性都很容易

14
00:01:14,659 --> 00:01:18,440
误导你自己或者其他人。

15
00:01:18,440 --> 00:01:25,440
作为一个可靠的测试，应该使用从未见过的新的样本数据。

16
00:01:25,440 --> 00:01:29,390
你应该把一部分数据保留到最后，在你选择算法，

17
00:01:29,390 --> 00:01:33,579
决定如何应用算法和过滤器等之前不要使用它。

18
00:01:33,579 --> 00:01:39,659
在最后的最后，已经完成了所有这些，在全新的数据上运行

19
00:01:39,659 --> 00:01:41,570
来评估它的性能。

20
00:01:41,570 --> 00:01:47,500
不要试图通过改变来改善它以获得更好的结果。

21
00:01:47,500 --> 00:01:51,659
总是在全新的数据上做最终的运行。

22
00:01:51,659 --> 00:01:56,189
关于过度拟合，我们谈过很多了，这基本上是一类问题。

23
00:01:56,189 --> 00:02:00,820
当然，你知道不要用训练数据做测试。

24
00:02:00,820 --> 00:02:05,030
我们一直在强调这个问题。

25
00:02:05,030 --> 00:02:09,370
无论用哪种方式来开发的数据都是被污染的。

26
00:02:09,370 --> 00:02:14,650
每次你用一些数据帮你选择过滤器或者分类器，

27
00:02:14,650 --> 00:02:20,250
或者处理问题的方法之后，数据都被污染了。

28
00:02:20,250 --> 00:02:24,470
你应该用全新的数据得到评价结果。

29
00:02:24,470 --> 00:02:29,400
留一些评估数据直到过程的最后。

30
00:02:29,400 --> 00:02:34,239
这是第一条建议。

31
00:02:34,239 --> 00:02:38,280
另外一件事，我至今为止没有告诉过你，就是残缺数据。

32
00:02:38,280 --> 00:02:45,280
真实的数据，部分数据残缺是十分常见的。

33
00:02:45,370 --> 00:02:46,579
它们没有被记录。

34
00:02:48,220 --> 00:02:53,579
它们可能是未知的；我们可能忘了记录了；它们可能是不相干的。

35
00:02:55,810 --> 00:03:00,310
有两个基本的策略可以处理数据集中的残缺数据。

36
00:03:00,310 --> 00:03:05,970
你可以忽略属性值残缺的实例，或者找到某种方法，

37
00:03:05,970 --> 00:03:08,780
忽略那个实例的特定属性。

38
00:03:08,780 --> 00:03:13,260
或者你可以把残缺的数据当作另一个可能的值。

39
00:03:15,060 --> 00:03:20,790
你需要问自己，事实上一个值丢失是否有重要意义？

40
00:03:20,799 --> 00:03:24,419
他们说如果你不舒服，然后去看医生，他帮你做了检查：

41
00:03:24,419 --> 00:03:30,370
如果你只记录了他做的检查（而不是检查的结果，

42
00:03:30,370 --> 00:03:34,669
仅仅是他选择做的检查），这很有可能你可以

43
00:03:34,669 --> 00:03:39,919
仅从做了的检查而不是检查结果，而了解你的问题。

44
00:03:39,919 --> 00:03:43,180
这是因为医生明智地选择检查。

45
00:03:43,180 --> 00:03:48,680
事实上，他没有选择一个检查并不意味着数值的残缺，

46
00:03:48,680 --> 00:03:49,660
或无意中的丢失。

47
00:03:49,660 --> 00:03:54,139
实际上，他选择不去做一些检查是有重要意义的。

48
00:03:54,139 --> 00:03:59,019
这里是“残缺”应该被当作另一个可能的值的情况。

49
00:03:59,019 --> 00:04:03,709
这里的数值残缺事实上是有意义的。

50
00:04:03,709 --> 00:04:06,959
但是，其他的情况，数值残缺可能只是简单的因为一个设备

51
00:04:06,959 --> 00:04:11,180
发生故障，或者其他一些原因（也许是有人忘了）。

52
00:04:11,180 --> 00:04:16,799
这里的数值残缺事实上是无意义的。

53
00:04:16,799 --> 00:04:20,850
几乎所有的机器学习算法都能处理残缺值。

54
00:04:20,850 --> 00:04:25,889
在ARFF文件中，如果你输入一个问号作为数据值，就会被当作是

55
00:04:25,889 --> 00:04:27,600
残缺值。

56
00:04:27,600 --> 00:04:30,530
所有Weka中的方法都能处理残缺值。

57
00:04:30,530 --> 00:04:33,759
但是，它们对于残缺值有不同的假设。

58
00:04:33,759 --> 00:04:39,460
如果你不明白这一点，会很容易被误导。

59
00:04:39,460 --> 00:04:45,550
我们举两个简单的众所周知的（对于我们）例子：OneR和J48。

60
00:04:45,550 --> 00:04:47,460
它们用不同的方式处理残缺值。

61
00:04:47,460 --> 00:05:00,740
载入名词性天气数据，应用OneR，得到43%。

62
00:05:00,740 --> 00:05:10,600
应用J48，得到50%。

63
00:05:10,600 --> 00:05:11,750
接下来，

64
00:05:11,750 --> 00:05:21,940
编辑这个数据集，把outlook的前四个no

65
00:05:21,940 --> 00:05:24,040
改为"missing"。

66
00:05:24,040 --> 00:05:26,580
我们用编辑器完成这件事。

67
00:05:26,580 --> 00:05:32,060
如果我们将这个文件输出为ARFF格式，

68
00:05:32,060 --> 00:05:36,600
我们会发现在文件这些值用问号替代。

69
00:05:37,380 --> 00:05:42,870
现在，如果我们看outlook，会发现有四个残缺值。

70
00:05:42,870 --> 00:05:49,870
如果你数下这些标签（2，4和4），共有10个标签。

71
00:05:50,350 --> 00:05:54,370
加上残缺的另外4个，组成了14个实例。

72
00:05:54,370 --> 00:06:00,120
让我们回去，再次运行J48。

73
00:06:00,120 --> 00:06:02,400
我们还是得到一样的结果50%。

74
00:06:03,400 --> 00:06:09,620
当然了，这是一个小型的数据集，但是事实上这里的结果并不受

75
00:06:09,620 --> 00:06:12,530
几个残缺值的影响。

76
00:06:12,530 --> 00:06:22,280
然而，如果我们使用OneR，将得到一个高得多的准确率93%。

77
00:06:26,370 --> 00:06:31,660
我们之前的规则是以outlook分支，我想这是我们以前做的。

78
00:06:31,660 --> 00:06:36,590
这里，有四种可能：如果值是sunny，结果是yes；如果是overcast，

79
00:06:36,590 --> 00:06:41,130
结果是yes；如果是rainy，结果是yes；如果是残缺，结果是no。

80
00:06:41,130 --> 00:06:45,870
这里，OneR认为`残缺值是重要的

81
00:06:45,870 --> 00:06:46,970
它可以用来分支。

82
00:06:46,970 --> 00:06:53,010
然而，如果你看到一个J48的树，它永远不会有

83
00:06:53,010 --> 00:06:54,280
一个对应残缺值的分叉。

84
00:06:54,280 --> 00:06:56,160
J48处理残缺值的方式是不同的。

85
00:06:56,160 --> 00:07:00,910
知道并记住这点很重要。

86
00:07:00,910 --> 00:07:07,910
这节课，我想告诉你的最后一点是“天下没有免费的午餐”。

87
00:07:08,290 --> 00:07:11,930
这在数据挖掘中也适用。

88
00:07:11,930 --> 00:07:13,440
举例说明。

89
00:07:13,440 --> 00:07:17,430
假如你有一个二类问题和100个二元属性。

90
00:07:17,430 --> 00:07:22,260
假设你有一个巨大的包含一百万实例并

91
00:07:22,260 --> 00:07:25,690
已分类的训练数据集。

92
00:07:25,690 --> 00:07:31,910
可能的实例数是2的100次方，因为有100个二元的

93
00:07:31,910 --> 00:07:33,120
属性。

94
00:07:33,120 --> 00:07:34,980
你已知是10的6次方个实例。

95
00:07:34,980 --> 00:07:40,160
所以，你未知分类的实例数是2的100次方减去10的6次方。

96
00:07:40,160 --> 00:07:47,780
让我告诉你，2的100次方减去10的6次方的结果是2的100次方的99.999...%。

97
00:07:47,780 --> 00:07:52,220
还有大量的例子，你是不知道它们的分类的。

98
00:07:52,220 --> 00:07:56,780
你怎么可能计算出它们呢？如果你应用数据挖掘的方法，

99
00:07:56,780 --> 00:08:02,130
它会计算，但是你怎么可能用已知的

100
00:08:02,130 --> 00:08:06,750
那么少的数据来计算。

101
00:08:06,750 --> 00:08:11,220
为了能概括，每个学习算法必须具有除所给数据之外的某些知识

102
00:08:11,220 --> 00:08:14,440
或假设。

103
00:08:14,440 --> 00:08:18,680
每一个学习算法隐含了一组假设。

104
00:08:18,680 --> 00:08:23,400
考虑那些假设的最好方法是

105
00:08:23,400 --> 00:08:26,320
回想我们在课程4.1看到的边界可视化。

106
00:08:26,320 --> 00:08:30,150
你看到了，不同的机器学习方法可绘制

107
00:08:30,150 --> 00:08:33,230
不同种类的实例空间的界限。

108
00:08:33,230 --> 00:08:39,530
这些界限对应一组关于我们可做的决定的假设。

109
00:08:39,530 --> 00:08:44,350
这里没有绝对的最好的算法；没有免费的午餐。

110
00:08:44,350 --> 00:08:46,900
没有单一的最好的算法。

111
00:08:46,900 --> 00:08:52,080
数据挖掘是一门试验科学，这就是为什么我们教大家

112
00:08:52,080 --> 00:08:55,010
如何自己实践数据挖掘。

113
00:08:56,240 --> 00:08:57,920
这只是个总结。

114
00:08:57,920 --> 00:09:02,250
保持怀疑：当人们告诉你数据挖掘的结果，告诉你他们得到的

115
00:09:02,250 --> 00:09:07,450
准确率，然后你一定要在你的全新的他们没有见过的数据上

116
00:09:07,450 --> 00:09:12,570
测试他们的分类器。

117
00:09:12,570 --> 00:09:15,480
过度拟合有很多种表现。

118
00:09:15,480 --> 00:09:19,640
不同的学习算法关于残缺值有不同的假设，这会

119
00:09:19,640 --> 00:09:21,400
使结果十分不同。

120
00:09:21,400 --> 00:09:26,950
没有到处适用的最好的学习方法。

121
00:09:26,950 --> 00:09:32,240
数据挖掘是一门试验科学，很容易被引用

122
00:09:32,240 --> 00:09:37,160
数据挖掘试验结果的人误导。

123
00:09:37,160 --> 00:09:37,890
就这些。

124
00:09:37,890 --> 00:09:40,540
去完成课后练习。

125
00:09:40,540 --> 00:09:42,080
下次课见！

126
00:09:42,080 --> 00:09:43,670
再见！