1
00:00:16,510 --> 00:00:23,510
大家好！这节课，我想给大家介绍

2
00:00:23,680 --> 00:00:28,740
评估机器学习算法性能的标准方法，交叉验证。

3
00:00:28,740 --> 00:00:35,740
前几节课，我们学习了如何用一个独立的测试数据集进行评估，并且了解了

4
00:00:36,640 --> 00:00:41,160
如何用训练数据进行评估（不要这么做）。

5
00:00:41,160 --> 00:00:47,190
我们还学习了采用预留的方法，拿出数据集的

6
00:00:47,190 --> 00:00:51,370
一小部分作为测试数据，其他剩余的部分作为训练数据。

7
00:00:51,370 --> 00:00:57,129
Weka的分类面板提供的第四个选项叫做交叉验证，

8
00:00:57,129 --> 00:01:02,049
这就是我们这节课要介绍的内容。

9
00:01:02,649 --> 00:01:07,680
交叉验证改良了多次预留法。

10
00:01:07,680 --> 00:01:14,310
我们曾经用不同的随机种子来运行预留法。

11
00:01:14,310 --> 00:01:17,659
这叫做重复预留法。

12
00:01:17,659 --> 00:01:21,860
交叉验证系统性地重复运行预留法。它通过

13
00:01:21,860 --> 00:01:26,080
减少预测误差来提高预留法的性能。

14
00:01:26,080 --> 00:01:30,680
我们载入训练数据并且创建一个分类器。

15
00:01:30,680 --> 00:01:34,370
然后，我们试着评估这个分类器的性能，

16
00:01:34,370 --> 00:01:39,020
这个评估会有一定的误差，因为这是建立在统计之上的。

17
00:01:39,020 --> 00:01:42,480
我们想要尽量减少评估的误差。

18
00:01:42,480 --> 00:01:48,330
交叉验证是一种减少误差的方法，一种叫做分层交叉验证， 交叉验证的变体，

19
00:01:48,330 --> 00:01:52,610
进一步减少了误差。

20
00:01:52,610 --> 00:01:58,580
本课，我会给大家解释这些方法。

21
00:01:58,580 --> 00:02:03,440
在前面的课程中，我们拿出10%作为测试数据，并且重复10次。

22
00:02:03,440 --> 00:02:06,310
这是一种重复预留法。

23
00:02:06,310 --> 00:02:13,310
我们载入一个数据集，重复10次将它分割成训练数据集

24
00:02:14,170 --> 00:02:16,450
和测试数据集。

25
00:02:16,450 --> 00:02:23,450
在交叉验证中，我们只分割一次，但是我们分成10份。

26
00:02:23,820 --> 00:02:28,690
然后，我们用其中的9份作为训练数据，

27
00:02:28,690 --> 00:02:30,920
剩余的一份作为测试数据。

28
00:02:31,320 --> 00:02:37,630
接着，还是用之前分割好的数据，我们用另外一组9份作为训练数据，

29
00:02:37,630 --> 00:02:39,960
剩余的一份作为测试数据。

30
00:02:39,960 --> 00:02:44,610
我们这样重复10次，每次都是用分割出的不同的数据作为测试数据。

31
00:02:44,610 --> 00:02:50,100
换句话说，我们把数据集分为10份，然后用每份

32
00:02:50,100 --> 00:02:57,100
轮流作为测试数据，剩余的作为训练数据，平均十次的结果。

33
00:02:57,160 --> 00:03:00,860
这就是10层交叉验证。

34
00:03:00,860 --> 00:03:07,040
把原始的数据随机分成10份（这些叫做分层），依次预留其中1份，

35
00:03:07,040 --> 00:03:07,960
然后平均多次的结果。

36
00:03:07,960 --> 00:03:14,270
所以，数据集中的每个数据都会用来作测试一次，训练九次。

37
00:03:14,270 --> 00:03:17,000
这就是10层交叉验证。

38
00:03:17,000 --> 00:03:22,320
分层交叉验证是一种简单的变体，当我们把原始数据分为

39
00:03:22,320 --> 00:03:28,110
10部分时，我们确保每一份的类值的比例

40
00:03:28,110 --> 00:03:29,150
大致是相同的。

41
00:03:29,150 --> 00:03:36,150
当然，有很多不同的方法将数据集分为10份。

42
00:03:36,150 --> 00:03:40,600
我们想选择一种能确保每一部分数据都具有分类

43
00:03:40,600 --> 00:03:42,880
代表性的分割方式。

44
00:03:42,880 --> 00:03:44,790
这就是分层交叉验证。

45
00:03:44,790 --> 00:03:50,880
它可以进一步降低评估误差。

46
00:03:50,880 --> 00:03:59,540
在我们做完交叉验证之后，Weka要对整个数据

47
00:03:59,540 --> 00:04:01,750
再运行一次。

48
00:04:01,750 --> 00:04:05,580
然后产生一个分类器，这就是我们实际使用的分类器。

49
00:04:05,580 --> 00:04:11,790
我们采用10层交叉验证是为了得到评估结果和它的误差，

50
00:04:11,790 --> 00:04:17,180
然后最终地，我们再次分类来得到一个

51
00:04:17,180 --> 00:04:20,000
可以实际应用的分类器。

52
00:04:22,550 --> 00:04:24,050
这就是我想说明的。

53
00:04:24,050 --> 00:04:28,150
交叉验证比简单的重复预留法精确。我们下节课会介绍这一点。

54
00:04:28,150 --> 00:04:31,120
分层交叉验证更加精确。

55
00:04:31,120 --> 00:04:37,760
Weka的默认值是分层交叉验证。

56
00:04:37,960 --> 00:04:42,650
使用10层交叉验证，Weka需要进行11次算法运算，前十次用每一份数据，

57
00:04:42,650 --> 00:04:47,820
最后一次用整个数据集。

58
00:04:47,820 --> 00:04:52,190
最实用的原则是，如果你有足够多的数据，你可以用百分比

59
00:04:52,190 --> 00:04:54,740
分割数据集并只评估一次。

60
00:04:54,740 --> 00:05:01,670
否则，如果你没有那么多数据，你需要使用分层交叉验证。

61
00:05:01,670 --> 00:05:03,830
多少数据算多呢？这是一个每个人想知道的问题。

62
00:05:03,830 --> 00:05:10,830
你知道一个字符串有多长吗？这很难说，但是（我们知道）它取决于一些方面。

63
00:05:11,150 --> 00:05:14,000
它取决于数据集包含类的个数。

64
00:05:14,000 --> 00:05:24,220
如果是一个只有两个类的数据集，那么，你有，例如100-1000条数据，

65
00:05:24,220 --> 00:05:29,490
应该足够得到一个可靠的评估结果了。

66
00:05:29,490 --> 00:05:33,750
你可按照90%和10%将数据集分为训练和测试数据。

67
00:05:33,750 --> 00:05:39,560
对于二类的分类问题，如你有10,000条数据，我想这已足够

68
00:05:39,560 --> 00:05:43,360
多，你不需要使用交叉验证。

69
00:05:43,360 --> 00:05:50,130
如果，另一方面，数据有100个不同分类，这就不一样了，是吧？

70
00:05:50,130 --> 00:05:54,720
你将需要一个大得多的数据集，因为你希望每一个分类都能够

71
00:05:54,920 --> 00:05:57,790
被充分地评估。

72
00:05:57,790 --> 00:06:00,780
这个问题很难给出确切的答案，因为它视具体情况而定。

73
00:06:00,780 --> 00:06:05,790
如果你收集到了成千上万的数据，你也许只需要

74
00:06:05,790 --> 00:06:07,200
用预留法做一次。

75
00:06:07,200 --> 00:06:14,100
如果你只有少于1000的数据，即使是二类问题，你可能还是需要

76
00:06:14,100 --> 00:06:15,930
运行10层交叉验证。

77
00:06:15,930 --> 00:06:18,440
10层交叉验证需要更多运行时间。

78
00:06:18,440 --> 00:06:23,340
它需要10倍的时间，但是，一般每一次运行的时间非常短。

79
00:06:23,340 --> 00:06:29,770
你可以阅读课本的第五章第三节关于交叉验证的内容。

80
00:06:29,770 --> 00:06:35,030
现在请大家完成本课的课后练习。

81
00:06:35,030 --> 00:06:42,030
再见！