1
00:00:00,000 --> 00:00:01,924
>> [音乐播放]

2
00:00:01,924 --> 00:00:10,600

3
00:00:10,600 --> 00:00:13,280
>> 演讲嘉宾：欢迎回来，大家好。

4
00:00:13,280 --> 00:00:15,440
这是CS50。

5
00:00:15,440 --> 00:00:21,040
而今天，我们有很多的
有趣的东西可谈。

6
00:00:21,040 --> 00:00:25,500
不过，首先我要提醒
你的一些管理的事情。

7
00:00:25,500 --> 00:00:30,160
本周是测验之一，星期三
或为耶鲁部

8
00:00:30,160 --> 00:00:32,940
在周二和周四，周四。

9
00:00:32,940 --> 00:00:38,170
有测验点评
今晚在耶鲁大学，下午5:30到7:00。

10
00:00:38,170 --> 00:00:40,030
在哈佛，他们1昨天录制。

11
00:00:40,030 --> 00:00:43,000
每个人都可以观看，网上。

12
00:00:43,000 --> 00:00:49,406
>> 此外，本周末或下周初，
我们有我们的最后CS50讲座。

13
00:00:49,406 --> 00:00:51,450
[呻吟]我知道。

14
00:00:51,450 --> 00:00:54,140
它来了这么快。

15
00:00:54,140 --> 00:00:57,820
耶鲁大学的学生将有一个活
讲座在这里的法学院

16
00:00:57,820 --> 00:00:59,920
观众席上周五。

17
00:00:59,920 --> 00:01:01,140
会有蛋糕。

18
00:01:01,140 --> 00:01:05,570
哈佛的学生将有
桑德斯在最后一节课上周一。

19
00:01:05,570 --> 00:01:08,050
也会有蛋糕。

20
00:01:08,050 --> 00:01:14,000
>> 此外，本周上周五，对于那些
你们谁是来纽黑文，

21
00:01:14,000 --> 00:01:15,740
我们有CS50世博会。

22
00:01:15,740 --> 00:01:18,850
我们有超过30
不同的组注册

23
00:01:18,850 --> 00:01:22,530
告诉你一切
从自主帆船，

24
00:01:22,530 --> 00:01:27,170
该识别系统
数码人像，计算机

25
00:01:27,170 --> 00:01:32,100
音乐和电脑制作音乐。

26
00:01:32,100 --> 00:01:33,610
所以，请加入我们的行列。

27
00:01:33,610 --> 00:01:36,460
我认为这将是一个伟大的时刻。

28
00:01:36,460 --> 00:01:40,320
>> 但是，今天我们去
继续谈论AI，

29
00:01:40,320 --> 00:01:43,150
关于人工智能。

30
00:01:43,150 --> 00:01:46,070
和的事情之一
我们要拿到今天

31
00:01:46,070 --> 00:01:51,750
是如何的想法
使用人工智能来解决问题。

32
00:01:51,750 --> 00:01:54,690
现在，一如既往，让我们开始
简单的东西。

33
00:01:54,690 --> 00:01:57,120
我们要开始
一个简单的想法。

34
00:01:57,120 --> 00:01:59,920
这就是使用搜索。

35
00:01:59,920 --> 00:02:06,990
>> 所以，想象一分钟，我
有我需要执行的任务。

36
00:02:06,990 --> 00:02:11,970
我想有该任务
通过一些软件代理的自动化。

37
00:02:11,970 --> 00:02:17,100
想象一下，我想订一套
从航班，让我们说，波士顿

38
00:02:17,100 --> 00:02:20,040
到旧金山。

39
00:02:20,040 --> 00:02:24,230
我可以通过我可以使用
精彩的在线搜索之一

40
00:02:24,230 --> 00:02:28,790
工具，这是要干什么
基本相同的过程，我们是

41
00:02:28,790 --> 00:02:30,030
要穿行今天。

42
00:02:30,030 --> 00:02:34,100
但是，如果你没有这种
工具，你会怎么办？

43
00:02:34,100 --> 00:02:37,570
>> 好了，你可以看看和
看，说，我在波士顿。

44
00:02:37,570 --> 00:02:41,520
哪些航班可以给我吗？

45
00:02:41,520 --> 00:02:44,390
现在，也许我有三个
可能的航班从波士顿

46
00:02:44,390 --> 00:02:47,180
将适合的时间
当我需要离开。

47
00:02:47,180 --> 00:02:48,830
我能飞芝加哥。

48
00:02:48,830 --> 00:02:50,130
或者，我可以飞到迈阿密。

49
00:02:50,130 --> 00:02:53,340
或者，我可以飞到纽约。

50
00:02:53,340 --> 00:02:56,980
然后，我可以看看每个
这些目的地城市之一

51
00:02:56,980 --> 00:03:00,650
想想什么位置
我可能达到

52
00:03:00,650 --> 00:03:03,020
从每次个别城市。

53
00:03:03,020 --> 00:03:07,390
>> 因此，也许从芝加哥，我可以得到
直飞旧金山。

54
00:03:07,390 --> 00:03:09,550
这是非常好的。

55
00:03:09,550 --> 00:03:12,360
或者，我可以得到一个飞往丹佛的航班。

56
00:03:12,360 --> 00:03:16,970
现在，也许该航班到旧金山
是一个完美的解决方案，对我来说，

57
00:03:16,970 --> 00:03:19,530
但也许不会。

58
00:03:19,530 --> 00:03:22,180
也许我寻找的东西
这是一个有点便宜

59
00:03:22,180 --> 00:03:24,920
或者我的日程表更好一点。

60
00:03:24,920 --> 00:03:29,197
因此，我可以寻找其他什么
可能性可能是在那里。

61
00:03:29,197 --> 00:03:30,280
所以，我可以看看丹佛。

62
00:03:30,280 --> 00:03:33,870
而从丹佛，好吧，也许
我可以得到一个飞行奥斯汀。

63
00:03:33,870 --> 00:03:37,080
而从奥斯汀，也许我可以得到一个
飞往凤凰城，从凤凰城

64
00:03:37,080 --> 00:03:40,190
到旧金山。

65
00:03:40,190 --> 00:03:42,730
现在，我还没有完成。

66
00:03:42,730 --> 00:03:45,640
因为也许有一个
从纽约直达航班

67
00:03:45,640 --> 00:03:47,850
到旧金山，非常适合我。

68
00:03:47,850 --> 00:03:53,354
或者，也许有来自迈阿密的航班
通过丹佛，这是一个便宜很多。

69
00:03:53,354 --> 00:03:54,270
所以，我还是得去。

70
00:03:54,270 --> 00:03:58,200
我仍然要看看所有这些
我还没有进行调查的城市。

71
00:03:58,200 --> 00:04:04,220
我要彻底检查所有的
我可能有机会。

72
00:04:04,220 --> 00:04:09,610
>> 因此，从纽约，也许我可以得到一个
飞往纳什维尔，并从纳什维尔

73
00:04:09,610 --> 00:04:10,336
奥斯汀。

74
00:04:10,336 --> 00:04:11,460
然后，我知道我在哪里。

75
00:04:11,460 --> 00:04:14,252
然后我知道，从奥斯汀，我可以
飞往凤凰城，从凤凰城

76
00:04:14,252 --> 00:04:14,960
到旧金山。

77
00:04:14,960 --> 00:04:18,240

78
00:04:18,240 --> 00:04:22,830
如果我先飞到迈阿密，不过，
也许我可以从迈阿密的航班

79
00:04:22,830 --> 00:04:25,080
纳什维尔，或从迈阿密到奥斯汀。

80
00:04:25,080 --> 00:04:27,950

81
00:04:27,950 --> 00:04:30,860
>> 现在我已经尝试了所有
的可能性。

82
00:04:30,860 --> 00:04:36,310
我已经建立了这个图，
我显示了所有可能的途径

83
00:04:36,310 --> 00:04:37,790
我也许可以采取。

84
00:04:37,790 --> 00:04:40,510

85
00:04:40,510 --> 00:04:43,640
当我们表示这些
那样的问题，

86
00:04:43,640 --> 00:04:47,870
我们不会代表
他们明确地为这个图，

87
00:04:47,870 --> 00:04:51,590
因为该图没有表示
在这里，我们已经走了的历史。

88
00:04:51,590 --> 00:04:55,260
知道我的飞
凤凰城到旧金山

89
00:04:55,260 --> 00:05:01,690
不告诉我，我是否通过来
纳什维尔，或通过丹佛，或通过迈阿密。

90
00:05:01,690 --> 00:05:06,430
>> 因此，我会做的是
我要这个同样的问题，

91
00:05:06,430 --> 00:05:09,140
我将它表示为一棵树。

92
00:05:09,140 --> 00:05:14,300
并在树的根，在
顶，我会把我开始的地方，

93
00:05:14,300 --> 00:05:16,590
波士顿。

94
00:05:16,590 --> 00:05:19,310
并在波士顿，我将看看
所有的可能位置

95
00:05:19,310 --> 00:05:20,380
我可以前往。

96
00:05:20,380 --> 00:05:25,480
那么，在这种情况下，我有三个，
芝加哥，纽约和迈阿密。

97
00:05:25,480 --> 00:05:29,850
然后，我将探讨各
这些孩子在树上。

98
00:05:29,850 --> 00:05:32,690
>> 从芝加哥，我看到了
我有两个航班。

99
00:05:32,690 --> 00:05:35,940
我可以直接飞到
旧金山或丹佛。

100
00:05:35,940 --> 00:05:37,740
现在旧金山，这就是我的目标。

101
00:05:37,740 --> 00:05:39,790
这是我的目标。

102
00:05:39,790 --> 00:05:42,220
这将是这棵树的叶子。

103
00:05:42,220 --> 00:05:45,340
也就是说，我永远不会去
旧金山后的地方。

104
00:05:45,340 --> 00:05:47,850

105
00:05:47,850 --> 00:05:50,340
从丹佛，不过，
我可以从丹佛飞

106
00:05:50,340 --> 00:05:54,220
奥斯汀，奥斯汀凤凰，
从凤凰城到旧金山。

107
00:05:54,220 --> 00:05:56,050
而现在再说一次，我已经到了一个叶。

108
00:05:56,050 --> 00:05:59,470

109
00:05:59,470 --> 00:06:03,980
>> 我可以再回到下一个
城市，我还没有充分开发。

110
00:06:03,980 --> 00:06:07,440
这将是纽约，去
备份到我的树的顶端，

111
00:06:07,440 --> 00:06:09,160
下来到纽约。

112
00:06:09,160 --> 00:06:12,700
从纽约，我可以飞
纳什维尔，从纳什维尔到奥斯汀，

113
00:06:12,700 --> 00:06:17,290
从奥斯汀到凤凰，和
从凤凰城到旧金山。

114
00:06:17,290 --> 00:06:20,170
最后，一​​个城市我
还没有看呢，迈阿密。

115
00:06:20,170 --> 00:06:24,600
>> 那么，从迈阿密我说我有两个
可能性，纳什维尔和奥斯汀。

116
00:06:24,600 --> 00:06:28,810
如果我飞到纳什维尔，那么好吧我飞
从纳什维尔，奥斯汀，凤凰，

117
00:06:28,810 --> 00:06:29,640
到旧金山。

118
00:06:29,640 --> 00:06:33,600
如果我飞到奥斯汀，我飞奥斯汀，
凤凰城，旧金山。

119
00:06:33,600 --> 00:06:36,340
现在我有一棵树。

120
00:06:36,340 --> 00:06:37,230
这是一个完整的树。

121
00:06:37,230 --> 00:06:41,890
这是所有的可能性，
所有我可以采取的路径。

122
00:06:41,890 --> 00:06:44,310
也就是说，如果我开始在
树的顶部根

123
00:06:44,310 --> 00:06:47,860
我再往之一
叶，它告诉我，不仅

124
00:06:47,860 --> 00:06:50,480
在这里我要
最终，旧金山，

125
00:06:50,480 --> 00:06:53,670
但它告诉我的路线
我需要到那里。

126
00:06:53,670 --> 00:06:56,400

127
00:06:56,400 --> 00:06:59,690
>> 现在，这些哪一个是最好的？

128
00:06:59,690 --> 00:07:02,430
好了，一无所知
问题还没有告诉我

129
00:07:02,430 --> 00:07:04,710
其中哪些是最好的解决方案。

130
00:07:04,710 --> 00:07:09,270
也许我关心最关心
我有多少时间是在空气中，

131
00:07:09,270 --> 00:07:12,350
或距离是我飞。

132
00:07:12,350 --> 00:07:16,410
在这种情况下，芝加哥圣
旧金山可能是最短的数

133
00:07:16,410 --> 00:07:18,910
在航空里程。

134
00:07:18,910 --> 00:07:20,860
>> 也许我在乎成本。

135
00:07:20,860 --> 00:07:23,680
我们都知道直达航班
通常更昂贵。

136
00:07:23,680 --> 00:07:26,610
所以，如果我拿这个，也许
一种倒退路线

137
00:07:26,610 --> 00:07:30,650
通过迈阿密，纳什维尔，
奥斯汀，凤凰，也许那时

138
00:07:30,650 --> 00:07:34,070
我得到一个较低的价格。

139
00:07:34,070 --> 00:07:36,440
但我可以优化任何
我关心的标准。

140
00:07:36,440 --> 00:07:39,790
谁拥有最好的
飞机上的Wi-Fi无线，或

141
00:07:39,790 --> 00:07:43,110
机场拥有最好的食物。

142
00:07:43,110 --> 00:07:47,280
而且每个可能
给我一个不同的解决方案

143
00:07:47,280 --> 00:07:49,215
我看到的是最好的。

144
00:07:49,215 --> 00:07:51,990

145
00:07:51,990 --> 00:07:54,400
>> 这些种类的问题，
我们要去哪里

146
00:07:54,400 --> 00:07:58,480
打造出了这棵树
可能性，然后

147
00:07:58,480 --> 00:08:02,100
看看每那些
各个路径，并检查

148
00:08:02,100 --> 00:08:05,270
其中那些满足了
一个标准对我们来说，

149
00:08:05,270 --> 00:08:08,790
我们将调用
这些搜索问题。

150
00:08:08,790 --> 00:08:11,280
我们有很多的
算法，其中一些

151
00:08:11,280 --> 00:08:15,270
我们已经看到，去
探索那些树。

152
00:08:15,270 --> 00:08:19,270
我们能做到这一点的方式，我
只是做了一个深度优先搜索，

153
00:08:19,270 --> 00:08:22,900
下降尽可能我们可以直到我们
打叶，然后再回来了，

154
00:08:22,900 --> 00:08:24,787
而要正确回落。

155
00:08:24,787 --> 00:08:26,870
或者，我们可以做什么
所谓广度优先搜索。

156
00:08:26,870 --> 00:08:29,675
我们可以扩大一切
在顶部，然后

157
00:08:29,675 --> 00:08:31,550
一切一行
下方的是，然后

158
00:08:31,550 --> 00:08:35,240
一切下方的一行。

159
00:08:35,240 --> 00:08:41,250
这些搜索树
是十分重要的AI。

160
00:08:41,250 --> 00:08:46,570
但他们并没有完全得到
它的权利所有的时间。

161
00:08:46,570 --> 00:08:51,600
事实上，在很多情况下
我们真正关心的，

162
00:08:51,600 --> 00:08:54,430
我们要建立一棵树，
但我们实际上并不

163
00:08:54,430 --> 00:08:57,140
去决定一切的。

164
00:08:57,140 --> 00:09:00,940
>> 这些都是所谓的情况下，
对抗性搜索，也被称为

165
00:09:00,940 --> 00:09:05,390
如何写玩游戏
系统和得到报酬。

166
00:09:05,390 --> 00:09:07,940
但这些都是种
系统在哪里

167
00:09:07,940 --> 00:09:12,920
可能会选择当我去从
波士顿，我去旁边哪个城市。

168
00:09:12,920 --> 00:09:19,990
但在那之后，别人可能会
使在哪里我飞行的决定。

169
00:09:19,990 --> 00:09:24,040
因此，要建立这些
种结构，我们

170
00:09:24,040 --> 00:09:28,510
将不得不采取一种
不同的方法吧。

171
00:09:28,510 --> 00:09:31,060
我们不打算要能够
只是通过搜索树

172
00:09:31,060 --> 00:09:35,000
了，因为我们没有
一个是在控制

173
00:09:35,000 --> 00:09:38,180
其中每个决策点的。

174
00:09:38,180 --> 00:09:42,590
>> 因此，让我们想象一下一个简单的
游戏像井字棋。

175
00:09:42,590 --> 00:09:46,730
我可以从一个
完全空白板。

176
00:09:46,730 --> 00:09:49,580
而在井字棋，
x被打首发。

177
00:09:49,580 --> 00:09:53,890
所以，我能想到的一切
可能的行动是X可以使。

178
00:09:53,890 --> 00:09:57,420
如果我是一个打
在X，这是伟大的。

179
00:09:57,420 --> 00:10:01,020
我有九个可能
移动，我可以做到的。

180
00:10:01,020 --> 00:10:05,000
我可以把一个X中的任何一个
这些九个位置。

181
00:10:05,000 --> 00:10:10,710
>> 然后从每次的，我
可以想像接下来会发生什么。

182
00:10:10,710 --> 00:10:14,130
那么，在这种情况下，其他
玩家将获得转一转。

183
00:10:14,130 --> 00:10:15,660
Ø将获得转一转。

184
00:10:15,660 --> 00:10:19,510
和从每次的，有
将八个不同的地方

185
00:10:19,510 --> 00:10:22,980
其中O可能将他们的标志。

186
00:10:22,980 --> 00:10:25,790
>> 比方说，我决定，我是
打算把一个X在中心。

187
00:10:25,790 --> 00:10:28,810
这似乎总是喜欢
良好的开放性举措。

188
00:10:28,810 --> 00:10:34,870
我可以看看下面的是，
八种可能的举动，Ö使。

189
00:10:34,870 --> 00:10:37,320
现在，如果我打X，这是美妙的。

190
00:10:37,320 --> 00:10:41,740
我可以选择哪一个我
去，一个在中间。

191
00:10:41,740 --> 00:10:45,000
但是，现在O与其选择。

192
00:10:45,000 --> 00:10:48,750
而且我没有控制
在这一决定。

193
00:10:48,750 --> 00:10:51,670
>> 但是从每次的
可能的仓板，

194
00:10:51,670 --> 00:10:54,020
还有接着又
设置的可能性。

195
00:10:54,020 --> 00:10:56,700
当说到做到
我重新开机，我就

196
00:10:56,700 --> 00:11:01,500
来挑，说，好，
如果可移动到了，好了，

197
00:11:01,500 --> 00:11:06,110
中间点在左边，然后
我有一组的可能性

198
00:11:06,110 --> 00:11:09,740
在那里我可以把我的下一步行动。

199
00:11:09,740 --> 00:11:14,140
从这些，我可以考虑全部
他们下方的可能性。

200
00:11:14,140 --> 00:11:18,030
然后与O将得到
在那些选择。

201
00:11:18,030 --> 00:11:22,290
>> 而且我可以继续建设这个
树，直到我到了点

202
00:11:22,290 --> 00:11:26,960
在这里无论是有人
赢得game--那

203
00:11:26,960 --> 00:11:31,070
得到了被认为是一个叶node--
或董事会完全充满

204
00:11:31,070 --> 00:11:32,704
也没有人赢了。

205
00:11:32,704 --> 00:11:34,370
而这也将是一个叶节点。

206
00:11:34,370 --> 00:11:35,411
这将是一个平局。

207
00:11:35,411 --> 00:11:37,820

208
00:11:37,820 --> 00:11:41,680
>> 但棘手的事情与这
如果这只是一个常规的搜索

209
00:11:41,680 --> 00:11:44,269
的问题，我能
比方说，好了，X应该去这里。

210
00:11:44,269 --> 00:11:45,560
可是啊应该走的路那边。

211
00:11:45,560 --> 00:11:46,770
然后X应该走在这里。

212
00:11:46,770 --> 00:11:48,269
然后与O应该走的路那边。

213
00:11:48,269 --> 00:11:51,860
然后X可以得到三个
在一排，我赢了。

214
00:11:51,860 --> 00:11:54,870
而本场比赛将超过
在五个动作，三对我来说，

215
00:11:54,870 --> 00:11:57,710
二为我的对手。

216
00:11:57,710 --> 00:12:01,300
但我并不总是得到选择。

217
00:12:01,300 --> 00:12:03,720
>> 因此，不是，我们是
不得不做

218
00:12:03,720 --> 00:12:06,270
是我们将有
有一个新的战略。

219
00:12:06,270 --> 00:12:09,350
而战略
玩游戏的算法经常使用

220
00:12:09,350 --> 00:12:12,000
是所谓极小。

221
00:12:12,000 --> 00:12:15,500
的中心思想
极小的是，我们

222
00:12:15,500 --> 00:12:21,365
会挑，让移动
我们的对手可能出现的最坏集

223
00:12:21,365 --> 00:12:22,790
的动作，他们可以做到的。

224
00:12:22,790 --> 00:12:25,570

225
00:12:25,570 --> 00:12:28,870
它没有我好
选择一个移动的地方

226
00:12:28,870 --> 00:12:31,952
我也许能取胜后
即，因为我的对手不是

227
00:12:31,952 --> 00:12:33,160
要给我这样的机会。

228
00:12:33,160 --> 00:12:37,770
他们会选择一些
可怕的结局对我来说。

229
00:12:37,770 --> 00:12:42,010
所以我打算让
移动，迫使我的对手

230
00:12:42,010 --> 00:12:45,760
做一些事情对我来说更好。

231
00:12:45,760 --> 00:12:46,260
好吧。

232
00:12:46,260 --> 00:12:48,410
让我们来看看这发挥出来。

233
00:12:48,410 --> 00:12:51,640
因此，这里是我们的伪代码算法。

234
00:12:51,640 --> 00:12:54,450
我们将产生
整个游戏树。

235
00:12:54,450 --> 00:12:56,757
我们要打造
整个结构。

236
00:12:56,757 --> 00:12:57,840
然后我们会去。

237
00:12:57,840 --> 00:13:02,100
和在最底层，在每个
终端节点，在各叶片的，

238
00:13:02,100 --> 00:13:07,850
我们将评估如何
可贵的是，在我身上？

239
00:13:07,850 --> 00:13:11,690
而我们要的价值的东西，
是为我好为阳性。

240
00:13:11,690 --> 00:13:14,460
事情是不是为我好
将不太积极的，或零，

241
00:13:14,460 --> 00:13:16,480
甚至为负。

242
00:13:16,480 --> 00:13:19,240
>> 因此，井字棋，也许
一场胜利对我来说是很好的。

243
00:13:19,240 --> 00:13:20,290
这是一个。

244
00:13:20,290 --> 00:13:22,400
而领带是零。

245
00:13:22,400 --> 00:13:26,230
而东西是一个损失
我，也许这是一个消极的。

246
00:13:26,230 --> 00:13:29,620
所有的事情是更好的
这对我来说，得分越高

247
00:13:29,620 --> 00:13:32,160
它接收。

248
00:13:32,160 --> 00:13:36,690
从这些可能性在
底部，然后我们会筛选向上。

249
00:13:36,690 --> 00:13:40,650
而当这是我选择的机会
在一组备选的，

250
00:13:40,650 --> 00:13:44,460
我会选择一个的
拿到了最高分。

251
00:13:44,460 --> 00:13:47,200
>> 每当这是我的
反对者转而选择，

252
00:13:47,200 --> 00:13:52,350
我认为他们将
选择一个得分最低。

253
00:13:52,350 --> 00:13:56,090
如果我做这一切的方式
到树的顶部，

254
00:13:56,090 --> 00:14:03,150
我已经选择了一条路，让
我说，我能得到最好的结果，

255
00:14:03,150 --> 00:14:09,110
假设我的对手
使所有正确的行动。

256
00:14:09,110 --> 00:14:11,940
>> 好吧，让我们看看
这个动作的第一。

257
00:14:11,940 --> 00:14:14,980
然后我们将实际
看看它的代码。

258
00:14:14,980 --> 00:14:16,780
所以，想象一下我这棵大树。

259
00:14:16,780 --> 00:14:18,280
现在我不玩井字棋。

260
00:14:18,280 --> 00:14:20,405
我想给你
东西一点点更丰富。

261
00:14:20,405 --> 00:14:23,560
所以，我有一些游戏，
有许多不同的分数

262
00:14:23,560 --> 00:14:26,390
我可以有结尾。

263
00:14:26,390 --> 00:14:27,980
所以我建立这个完整的树。

264
00:14:27,980 --> 00:14:29,070
而且我可以先移动。

265
00:14:29,070 --> 00:14:31,290
我在树的根。

266
00:14:31,290 --> 00:14:36,150
>> 我能选择that--所以我得到
跨越该第一节点最大化。

267
00:14:36,150 --> 00:14:38,410
然后我的对手随便去哪儿。

268
00:14:38,410 --> 00:14:41,910
然后，我现在能去一次。

269
00:14:41,910 --> 00:14:46,830
这样下来在底部，我有一组
可能性，我可以选择，

270
00:14:46,830 --> 00:14:50,570
游戏中不同的终端状态。

271
00:14:50,570 --> 00:14:54,980
如果我在那很沮丧
最左边的角落，

272
00:14:54,980 --> 00:14:58,867
我看到，我有一个选择
八，七，和一个两者之间，

273
00:14:58,867 --> 00:15:00,450
好了，我是一个得到选择。

274
00:15:00,450 --> 00:15:02,910
所以我要选择
这其中的佼佼者。

275
00:15:02,910 --> 00:15:05,650
我要选择的八个。

276
00:15:05,650 --> 00:15:10,090
>> 所以，我知道，如果我
下来到这一点，

277
00:15:10,090 --> 00:15:13,890
我就可以拿到8分。

278
00:15:13,890 --> 00:15:17,410
如果我最终的下一个点
并且，在接下来的节点，

279
00:15:17,410 --> 00:15:20,760
九，一，或六，好了，我
要选择最好的那些。

280
00:15:20,760 --> 00:15:21,950
我会选择九。

281
00:15:21,950 --> 00:15:24,880
如果我有之间的选择
2，和四，和一，

282
00:15:24,880 --> 00:15:28,240
我会选择四，最高的。

283
00:15:28,240 --> 00:15:31,990
>> 现在，如果我看水平
上面说，我的对手

284
00:15:31,990 --> 00:15:34,440
是一个得到做出这样的选择。

285
00:15:34,440 --> 00:15:37,040
所以，我的对手到达
选择，我想给他

286
00:15:37,040 --> 00:15:39,250
的事情是怎么回事
让他八点，

287
00:15:39,250 --> 00:15:41,916
还是我给他的东西，是
打算给​​他9分，

288
00:15:41,916 --> 00:15:45,240
或东西是怎么回事
给他四点？

289
00:15:45,240 --> 00:15:49,130
而我的对手，是
理性的，是怎么回事

290
00:15:49,130 --> 00:15:53,470
要选择那些最小的，
是要选择四个。

291
00:15:53,470 --> 00:15:56,020
>> 我能做到这一点
整个树。

292
00:15:56,020 --> 00:15:59,110
我可以去到
中间套三。

293
00:15:59,110 --> 00:16:01,517
我可以进行选择
一，三，五。

294
00:16:01,517 --> 00:16:02,350
我能选择。

295
00:16:02,350 --> 00:16:03,810
所以，我选择了五。

296
00:16:03,810 --> 00:16:05,340
我可以选择三种，九两。

297
00:16:05,340 --> 00:16:07,570
我能选择，所以我选择的九个。

298
00:16:07,570 --> 00:16:09,290
六，五或二，我选择。

299
00:16:09,290 --> 00:16:11,539
我能选择的六个。

300
00:16:11,539 --> 00:16:13,080
在该水平之上，谁可以选择呢？

301
00:16:13,080 --> 00:16:16,280

302
00:16:16,280 --> 00:16:18,140
谁可以选择呢？

303
00:16:18,140 --> 00:16:20,000
另外一个人，我的对手。

304
00:16:20,000 --> 00:16:22,583
因此，他们选择5个，
九，六，哪一个？

305
00:16:22,583 --> 00:16:23,410
>> 听众：五。

306
00:16:23,410 --> 00:16:25,250
>> 演讲嘉宾：他们选择的五个。

307
00:16:25,250 --> 00:16:27,400
他们能选择的最低。

308
00:16:27,400 --> 00:16:29,690
然后最后一个，
选择一个，两个或三个。

309
00:16:29,690 --> 00:16:31,720
我能选择，所以我选择三种。

310
00:16:31,720 --> 00:16:34,370
九，七，或两个，我选择九岁。

311
00:16:34,370 --> 00:16:37,070
而11，六，或四个，我选择11。

312
00:16:37,070 --> 00:16:41,190
我的对手则选择三，
9，或11，选择最小。

313
00:16:41,190 --> 00:16:43,290
他给了我三个。

314
00:16:43,290 --> 00:16:47,780
然后最后在顶部
树，我可以重新选择。

315
00:16:47,780 --> 00:16:51,190
而我得到之间做出选择
四，五，或三。

316
00:16:51,190 --> 00:16:52,270
所以，我把五。

317
00:16:52,270 --> 00:16:55,070

318
00:16:55,070 --> 00:17:00,891
>> 如果我控制一切，我会
采取了导致11的路径。

319
00:17:00,891 --> 00:17:02,390
但我不明白做出这样的选择。

320
00:17:02,390 --> 00:17:04,220
如果我走这条路。

321
00:17:04,220 --> 00:17:10,710
我的对手会强迫我进入
这导致了三个选择。

322
00:17:10,710 --> 00:17:14,530
所以，我能做的最好的是
采取这一中间分支，

323
00:17:14,530 --> 00:17:19,859
做出这样的选择这是最终
要带领我到五点。

324
00:17:19,859 --> 00:17:23,230
这就是极小呢。

325
00:17:23,230 --> 00:17:23,807
>> 好吧。

326
00:17:23,807 --> 00:17:24,890
让我们来看看这个。

327
00:17:24,890 --> 00:17:27,480

328
00:17:27,480 --> 00:17:32,330
因此，这里的CS50
IDE是一个程序，

329
00:17:32,330 --> 00:17:36,540
实现极小玩井字棋。

330
00:17:36,540 --> 00:17:40,100
我们要打造
向上的表示。

331
00:17:40,100 --> 00:17:44,390
我们将有两个opponent--
或者两个球员，我们的电脑

332
00:17:44,390 --> 00:17:46,090
播放器和一个人的球员。

333
00:17:46,090 --> 00:17:48,980

334
00:17:48,980 --> 00:17:53,090
玩家头号将被打
在O.那将是机器的球员。

335
00:17:53,090 --> 00:17:55,747
他们得到第二招。

336
00:17:55,747 --> 00:17:57,830
而其他的球员，我们的
人类的球员，将是X.

337
00:17:57,830 --> 00:17:59,880
>> 而为了让我的生活
一点简单的，我要去

338
00:17:59,880 --> 00:18:03,060
标记该玩家负值。

339
00:18:03,060 --> 00:18:05,026
所以我只能乘
由负一换

340
00:18:05,026 --> 00:18:06,400
之间的一个播放器和其他。

341
00:18:06,400 --> 00:18:09,030

342
00:18:09,030 --> 00:18:12,250
好吧，让我们来看看
我们实际上是要干什么。

343
00:18:12,250 --> 00:18:15,840
我们要确定我们的董事会。

344
00:18:15,840 --> 00:18:19,060
这将是，嗯，我们要去
以允许它有三个由三个，

345
00:18:19,060 --> 00:18:21,580
或者，我们甚至可以玩
五经五天或七天

346
00:18:21,580 --> 00:18:28,870
七井字棋，如果你想
像的基础上，一些尺寸D.

347
00:18:28,870 --> 00:18:31,260
>> 并且我们将有一对夫妇
辅助函数

348
00:18:31,260 --> 00:18:34,360
那会做这样的事情
初始化screen--还是遗憾，

349
00:18:34,360 --> 00:18:38,900
初始化我们的变量，清除
屏幕上，绘制电路板在屏幕上，

350
00:18:38,900 --> 00:18:41,060
一个检查板
看是否

351
00:18:41,060 --> 00:18:44,520
有一个赢家，一个
解析通过命令行，

352
00:18:44,520 --> 00:18:50,670
只是助阵，一个读取
输入，以及一个函数调用极小。

353
00:18:50,670 --> 00:18:52,746
这就是一个
我们最关心的。

354
00:18:52,746 --> 00:18:54,120
但是，让我们先来看看主。

355
00:18:54,120 --> 00:18:57,490

356
00:18:57,490 --> 00:18:58,510
>> 我们做什么？

357
00:18:58,510 --> 00:19:00,570
好了，我们要
分析我们的命令行，

358
00:19:00,570 --> 00:19:04,300
只是读，看看
维板，我们希望有。

359
00:19:04,300 --> 00:19:07,330
我们将初始化我们的董事会。

360
00:19:07,330 --> 00:19:10,360
然后，我们会输入一个
野生大循环，反复

361
00:19:10,360 --> 00:19:16,630
接受移动直到游戏
赢了，或者有没有向左移动。

362
00:19:16,630 --> 00:19:20,560
每次我们去通过
循环中，我们将清除屏幕。

363
00:19:20,560 --> 00:19:23,290
我们要开董事会在屏幕上。

364
00:19:23,290 --> 00:19:28,750
我们是那种故意
这些抽象走为子程序，

365
00:19:28,750 --> 00:19:32,030
所以，我们不必过于担心
他们是如何发生的细节。

366
00:19:32,030 --> 00:19:33,480
>> 你必须在代码后的今天。

367
00:19:33,480 --> 00:19:37,970
如果你想看看通过
并找出，你可以看到他们所有。

368
00:19:37,970 --> 00:19:39,890
但是，我们会得出一个板在屏幕上。

369
00:19:39,890 --> 00:19:43,620
然后我们会检查并
看，我们有一个赢家？

370
00:19:43,620 --> 00:19:46,290
曾有人赢了这场比赛？

371
00:19:46,290 --> 00:19:49,260
如果他们有，我们将打印
出了胜利的消息。

372
00:19:49,260 --> 00:19:51,680
并且我们将结束游戏。

373
00:19:51,680 --> 00:19:54,510
>> 我们还将检查和
看看有没有打领带。

374
00:19:54,510 --> 00:19:56,620
这将是很容易，看看是否有一个平手。

375
00:19:56,620 --> 00:20:00,700
这意味着，所有的位已满，
但还没有分出胜负呢。

376
00:20:00,700 --> 00:20:03,580
我们可以声明领带和完成。

377
00:20:03,580 --> 00:20:10,530
那么真正的meat--如果
它是一台机器的球员，

378
00:20:10,530 --> 00:20:14,120
我们将允许
机播放器搜索

379
00:20:14,120 --> 00:20:19,500
通过使用这种极大极小​​算法，
找到最好的招之能。

380
00:20:19,500 --> 00:20:22,310
然后我们会把这个拉升。

381
00:20:22,310 --> 00:20:27,640
>> 否则，如果它是一个人的球员，
我们将阅读从人的一些输入。

382
00:20:27,640 --> 00:20:30,800
然后，无论是人
玩家或机器播放器，

383
00:20:30,800 --> 00:20:32,800
我们很少做一对夫妇
错误检查位，

384
00:20:32,800 --> 00:20:36,910
以确保它保持的范围内
董事会的实际尺寸

385
00:20:36,910 --> 00:20:40,040
我们有，要确保
这空间是空的，

386
00:20:40,040 --> 00:20:43,570
没有人的放
片中出现了。

387
00:20:43,570 --> 00:20:45,810
然后，我们就放
一块电路板上，

388
00:20:45,810 --> 00:20:51,550
改变播放器到下一个层，和
增加了多少动作发生。

389
00:20:51,550 --> 00:20:54,090
>> 这对于主循环
我们井字棋游戏。

390
00:20:54,090 --> 00:20:57,000

391
00:20:57,000 --> 00:21:02,340
极小的话，是完全
该算法之前我们。

392
00:21:02,340 --> 00:21:04,710
唯一的调整是
我们已经取得了让我们

393
00:21:04,710 --> 00:21:07,290
可以播放高
维板是我们

394
00:21:07,290 --> 00:21:11,070
保持这种所谓的深度额外的参数。

395
00:21:11,070 --> 00:21:14,870
和深度只是说，如果我
通过树向下搜索

396
00:21:14,870 --> 00:21:19,022
而我得到这么远了
超出一定水平的深度

397
00:21:19,022 --> 00:21:20,730
我只是不希望
再往前走，

398
00:21:20,730 --> 00:21:25,630
我会停下来，只是
评估委员会在这一点上。

399
00:21:25,630 --> 00:21:27,310
我会检查，看看是否有一个赢家。

400
00:21:27,310 --> 00:21:29,240
如果有一个赢家，我回报他们。

401
00:21:29,240 --> 00:21:31,720
否则，我将经历一个循环。

402
00:21:31,720 --> 00:21:34,380
我会说，所有的
可能位置

403
00:21:34,380 --> 00:21:38,080
那我可能
拿我的举动，我会

404
00:21:38,080 --> 00:21:43,760
建立一个假想的板，
包括我的举动上板，

405
00:21:43,760 --> 00:21:45,960
然后递归调用极小。

406
00:21:45,960 --> 00:21:49,360

407
00:21:49,360 --> 00:21:53,900
>> 如果这是我的举动，我可以找到
一个有足够快的最大比分。

408
00:21:53,900 --> 00:21:58,710
如果是我的对手的举动，我们发现
那一定的最低分数的人。

409
00:21:58,710 --> 00:22:02,240
和其他一切是
只是记录保存。

410
00:22:02,240 --> 00:22:04,789
好吧，让我们看看这个运行。

411
00:22:04,789 --> 00:22:06,830
其实，也许我们可以
找几个志愿者

412
00:22:06,830 --> 00:22:09,930
拿出玩井字棋。

413
00:22:09,930 --> 00:22:12,780
[听不清]之一，和一个
多，二，就在那里。

414
00:22:12,780 --> 00:22:13,550
上来吧。

415
00:22:13,550 --> 00:22:19,290

416
00:22:19,290 --> 00:22:23,650
>> 因此，让我们继续前进，
完全重新启动此。

417
00:22:23,650 --> 00:22:24,150
所以，喜。

418
00:22:24,150 --> 00:22:24,920
>> 听众：你好。

419
00:22:24,920 --> 00:22:25,420
>> 演讲嘉宾：你叫什么名字？

420
00:22:25,420 --> 00:22:26,086
>> 听众：Gorav。

421
00:22:26,086 --> 00:22:26,840
演讲嘉宾：Gorav。

422
00:22:26,840 --> 00:22:27,800
>> 听众：我是莱拉。

423
00:22:27,800 --> 00:22:29,490
>> 演讲嘉宾：而且莱拉，和莱拉，对不起。

424
00:22:29,490 --> 00:22:30,384
上来吧。

425
00:22:30,384 --> 00:22:32,050
Gorav，我们将让你先走。

426
00:22:32,050 --> 00:22:37,710
而我要问你是不是
非常良好的井字棋的球员。

427
00:22:37,710 --> 00:22:40,130
好了，所有的压力是关闭你。

428
00:22:40,130 --> 00:22:44,660
让我们来看看，虽然，我们的机器
玩家其实可以做一些聪明。

429
00:22:44,660 --> 00:22:45,310
因此，继续前进。

430
00:22:45,310 --> 00:22:49,830
你会在哪个坐标输入
你想将你的X研究。

431
00:22:49,830 --> 00:22:55,170
A0，OK，机器已经
马上，把它的标记在A1中。

432
00:22:55,170 --> 00:22:56,640
>> 把O于董事会。

433
00:22:56,640 --> 00:22:58,970
好了，现在继续。

434
00:22:58,970 --> 00:23:00,193
您要在何处去？

435
00:23:00,193 --> 00:23:03,510

436
00:23:03,510 --> 00:23:05,090
C2。

437
00:23:05,090 --> 00:23:08,430
我们的机器播放器已
广场中间，挡住你。

438
00:23:08,430 --> 00:23:10,320
所以这是一个很好的，
聪明的为它做。

439
00:23:10,320 --> 00:23:13,430

440
00:23:13,430 --> 00:23:14,250
你阻止它。

441
00:23:14,250 --> 00:23:15,210
这是非常好的。

442
00:23:15,210 --> 00:23:16,390
它开出角球那里。

443
00:23:16,390 --> 00:23:23,890

444
00:23:23,890 --> 00:23:30,430
>> 而且它会迫使你
取最后一个空间，B0。

445
00:23:30,430 --> 00:23:32,220
而本场比赛以平局结束。

446
00:23:32,220 --> 00:23:35,030
但它起到了合理的
游戏对你，对不对？

447
00:23:35,030 --> 00:23:36,956
好，非常感谢，Gorav。

448
00:23:36,956 --> 00:23:40,860
>> [掌声]

449
00:23:40,860 --> 00:23:44,723
>> 好吧，莱拉，我们要去
她对你的游戏在这里。

450
00:23:44,723 --> 00:23:46,940
>> 听众：哦，太棒了。

451
00:23:46,940 --> 00:23:49,950
>> 演讲嘉宾：我们打算给
你四乘四井字棋。

452
00:23:49,950 --> 00:23:54,760
现在，在四乘四，你必须要赢
四成一排，没有三连胜。

453
00:23:54,760 --> 00:23:56,135
而这一切都属于你。

454
00:23:56,135 --> 00:24:02,180

455
00:24:02,180 --> 00:24:04,420
所以蕾拉了D1。

456
00:24:04,420 --> 00:24:11,730
我们现在要遵循
我们在这里的电脑玩家。

457
00:24:11,730 --> 00:24:16,910
三三井字棋是那种
东西，很容易对我们所有人。

458
00:24:16,910 --> 00:24:21,960
但它仍然很好看
电脑玩家作出明智的举动。

459
00:24:21,960 --> 00:24:23,725
四乘四到达
是有点棘手。

460
00:24:23,725 --> 00:24:42,960

461
00:24:42,960 --> 00:24:44,230
>> 做得好。

462
00:24:44,230 --> 00:24:46,210
好吧，让蕾拉的结束了。

463
00:24:46,210 --> 00:24:48,270
哦，我们应该已经结束了在那里。

464
00:24:48,270 --> 00:24:51,870
但是，让我们做一起来这里。

465
00:24:51,870 --> 00:24:53,480
所以蕾拉，谢谢。

466
00:24:53,480 --> 00:24:55,112
做得好。

467
00:24:55,112 --> 00:24:57,517
>> [掌声]

468
00:24:57,517 --> 00:25:00,410

469
00:25:00,410 --> 00:25:04,750
>> 因此，我们井字棋玩家进入
通过和发现的地点，

470
00:25:04,750 --> 00:25:07,040
解决了他们使用这种极小。

471
00:25:07,040 --> 00:25:08,990
而且我有一个深度设置
上，以便它

472
00:25:08,990 --> 00:25:11,010
不会跑的太快，
这可能是为什么

473
00:25:11,010 --> 00:25:16,790
蕾拉能够很好地向前走
她做到了，做得很好。

474
00:25:16,790 --> 00:25:20,450
但是，这些系统只
经过和蛮力

475
00:25:20,450 --> 00:25:23,870
走得更深，更深，更深，
并不断寻找解决方案

476
00:25:23,870 --> 00:25:29,890
他们需要，那些类型的系统
在这些相当成功的，好了，

477
00:25:29,890 --> 00:25:32,700
标准的棋盘游戏。

478
00:25:32,700 --> 00:25:37,060
>> 而事实上，如果我们看一下
三乘三井字棋游戏，

479
00:25:37,060 --> 00:25:40,040
这基本上是一个解决的问题。

480
00:25:40,040 --> 00:25:45,430
这是一个美妙的图
从兰德尔·门罗在XKCD，

481
00:25:45,430 --> 00:25:52,130
显示哪些打动你应该
走，给你的对手的动作。

482
00:25:52,130 --> 00:25:56,420
这是我们可以
随便指定时间提前。

483
00:25:56,420 --> 00:26:00,180
但是，当我们得到更多的会发生什么
复杂的游戏，更复杂的游戏，

484
00:26:00,180 --> 00:26:05,690
那里有更大的板，更
的可能性，更深层次的战略是什么？

485
00:26:05,690 --> 00:26:09,660
>> 事实证明，这
强力搜索仍

486
00:26:09,660 --> 00:26:14,150
确实相当不错，除了
当你到了点

487
00:26:14,150 --> 00:26:19,230
其中，该树是如此之大
你不能代表一切。

488
00:26:19,230 --> 00:26:22,370

489
00:26:22,370 --> 00:26:28,280
当你无法计算整个树，
当你无法前进，并推

490
00:26:28,280 --> 00:26:32,204
你自己，你已经点
得到整个树在内存中，

491
00:26:32,204 --> 00:26:34,370
或者是否可以得到它
在内存中，它只是

492
00:26:34,370 --> 00:26:39,200
带你太长时间进行搜索
它，你必须做一些更聪明。

493
00:26:39,200 --> 00:26:42,620

494
00:26:42,620 --> 00:26:46,450
>> 为了做到这一点，你
必须做两件事情。

495
00:26:46,450 --> 00:26:49,030
首先，你必须要找到一些
限制你的深度的方法。

496
00:26:49,030 --> 00:26:50,370
嗯，这是确定。

497
00:26:50,370 --> 00:26:55,740
我们可以找到一些不错的，最低限度
并说，你只能走这么深。

498
00:26:55,740 --> 00:27:00,890
但是，当你这样做，这意味着你
有这些部分不完整的板。

499
00:27:00,890 --> 00:27:04,770
而你要选择，我喜欢
这部分不完整的主板，

500
00:27:04,770 --> 00:27:08,600
或者这部分不完整的主板？

501
00:27:08,600 --> 00:27:11,910
>> 而在我们的四经
4井字棋游戏，

502
00:27:11,910 --> 00:27:15,240
我们的电脑玩家得到了下来
的底部，它说，

503
00:27:15,240 --> 00:27:16,800
我有两个不同的电路板。

504
00:27:16,800 --> 00:27:17,940
没有一个是一个双赢。

505
00:27:17,940 --> 00:27:19,120
没有一个是亏损的。

506
00:27:19,120 --> 00:27:22,070
没有一个是一个平局。

507
00:27:22,070 --> 00:27:24,100
如何选择它们之间？

508
00:27:24,100 --> 00:27:26,200
和它没有一个
这样做的聪明的办法。

509
00:27:26,200 --> 00:27:28,910

510
00:27:28,910 --> 00:27:32,850
>> 我们看到这种
评估发生的事情

511
00:27:32,850 --> 00:27:35,290
随着我们进入更复杂的游戏。

512
00:27:35,290 --> 00:27:37,600
国际象棋是一个很好的例子。

513
00:27:37,600 --> 00:27:41,550
在国际象棋中，我们有，第一
所有的人，一个较大的电路板。

514
00:27:41,550 --> 00:27:43,370
我们有更多的作品。

515
00:27:43,370 --> 00:27:47,930
与这些片的定位
和方式，这些棋子

516
00:27:47,930 --> 00:27:50,370
是非常重要的。

517
00:27:50,370 --> 00:27:53,700
所以，如果我想用极小，
我需要能够指定

518
00:27:53,700 --> 00:27:58,240
并说，此板，其中，
没有人赢了还是输呢，

519
00:27:58,240 --> 00:28:04,310
在某种程度上这比其他更好的
板，在那里没有人赢了还是输。

520
00:28:04,310 --> 00:28:06,740
>> 为了做到这一点，我可能会做
像我可能只是

521
00:28:06,740 --> 00:28:10,787
算我多少块确实有
多少个，你呢？

522
00:28:10,787 --> 00:28:12,870
或者，我可以给不同
件的不同点。

523
00:28:12,870 --> 00:28:14,420
我的皇后是20分。

524
00:28:14,420 --> 00:28:16,500
你的棋子是一分不值。

525
00:28:16,500 --> 00:28:18,920
谁拥有更多的积分总？

526
00:28:18,920 --> 00:28:22,300
或者，我可能会考虑一些事情，如，
谁拥有更好的板位置？

527
00:28:22,300 --> 00:28:26,820
轮到谁下一个，
什么我可以

528
00:28:26,820 --> 00:28:31,220
做评估更准确​​地
其中这些可能性

529
00:28:31,220 --> 00:28:34,660
是没有好
详尽考虑

530
00:28:34,660 --> 00:28:36,565
一举一动都可能到来之后。

531
00:28:36,565 --> 00:28:39,740

532
00:28:39,740 --> 00:28:45,130
>> 现在，使这项工作，
的事情的One

533
00:28:45,130 --> 00:28:48,680
将成为非常重要的
对我们来说不只是直线运动

534
00:28:48,680 --> 00:28:53,720
下降到特定深度
限制，但不能说，

535
00:28:53,720 --> 00:28:59,380
这些想法一说我
已经是如此糟糕，它的

536
00:28:59,380 --> 00:29:02,280
不值得考虑
所有的可能的方法

537
00:29:02,280 --> 00:29:06,680
事情可以去每况愈下。

538
00:29:06,680 --> 00:29:12,760
为了做到这一点，我们将添加到极小
一个原则叫做ALPH-β。

539
00:29:12,760 --> 00:29:16,340
而α-β表示，
如果你有一个糟糕的主意，

540
00:29:16,340 --> 00:29:22,840
不要浪费你的时间尝试
找出它究竟是如何糟糕。

541
00:29:22,840 --> 00:29:24,990
>> 因此，这里就是我们要做的。

542
00:29:24,990 --> 00:29:28,620
我们将采取同样的
我们收到的原则，

543
00:29:28,620 --> 00:29:32,200
同样极小极大类型
搜索，只是我们

544
00:29:32,200 --> 00:29:37,570
要跟踪，不仅是
我们有实际价值，但我们会

545
00:29:37,570 --> 00:29:41,440
跟踪的最佳可能
值，我能得到，

546
00:29:41,440 --> 00:29:45,700
和最坏的可能
结果，我可以有。

547
00:29:45,700 --> 00:29:50,470
而任何时候，最坏的可能
事情正在寻找可能的是，

548
00:29:50,470 --> 00:29:52,694
我会抛弃树的一部分。

549
00:29:52,694 --> 00:29:54,610
我不会甚至不屑
看它了。

550
00:29:54,610 --> 00:29:57,680

551
00:29:57,680 --> 00:30:02,600
>> 好了，所以可想而知，我们开始
与此完全相同的博弈树。

552
00:30:02,600 --> 00:30:05,200
而现在我们将去
再次回落，一路下行

553
00:30:05,200 --> 00:30:07,200
到左下角。

554
00:30:07,200 --> 00:30:11,180
而在这左下角，我们
看看我们评估这款主板。

555
00:30:11,180 --> 00:30:15,700
也许这是一个四乘四井字棋
板，或者这是一个国际象棋棋盘。

556
00:30:15,700 --> 00:30:18,620
但是，大家看看吧，我们评估
它，我们得到八的价值。

557
00:30:18,620 --> 00:30:22,290

558
00:30:22,290 --> 00:30:28,030
>> 在这一点上，我们知道
我们将得到至少

559
00:30:28,030 --> 00:30:32,380
八点从这个底部决定。

560
00:30:32,380 --> 00:30:36,620
不要紧什么其他
两个是，这七有两个。

561
00:30:36,620 --> 00:30:38,580
它们可以是任何的值
他们想要的。

562
00:30:38,580 --> 00:30:41,279
我们要得到的
至少8分。

563
00:30:41,279 --> 00:30:43,070
好吧，但是我们可以
继续检查。

564
00:30:43,070 --> 00:30:45,080
也许其中之一是超过八个更好。

565
00:30:45,080 --> 00:30:46,000
>> 我们来看一下七个。

566
00:30:46,000 --> 00:30:46,910
那是超过八个好？

567
00:30:46,910 --> 00:30:48,680
没有，这并不改变
我们的意见都没有。

568
00:30:48,680 --> 00:30:49,460
我们看看两个。

569
00:30:49,460 --> 00:30:50,543
那是超过八个好？

570
00:30:50,543 --> 00:30:52,580
没有，这并不改变
我们的意见都没有。

571
00:30:52,580 --> 00:30:55,480
所以，现在我们知道我们已经用尽
所有存在的可能性。

572
00:30:55,480 --> 00:30:58,330
我们不会得到
任何超过八个好。

573
00:30:58,330 --> 00:31:01,310
我们将得到完全八强。

574
00:31:01,310 --> 00:31:03,825
>> 因此，我们改变节点
说了，就是现在是必然的。

575
00:31:03,825 --> 00:31:07,010

576
00:31:07,010 --> 00:31:10,270
我们去了一个级别上面。

577
00:31:10,270 --> 00:31:13,820
现在我们知道的东西
有关最小化水平。

578
00:31:13,820 --> 00:31:18,560
我们知道，我们永远不会得到
八个多百分点，如果我们再往

579
00:31:18,560 --> 00:31:20,910
这个方向努力。

580
00:31:20,910 --> 00:31:22,980
因为即使这些
其他两个部门转出

581
00:31:22,980 --> 00:31:26,170
是梦幻般的，值得
成千上万的每一个点，

582
00:31:26,170 --> 00:31:31,666
我们的对手会给我们
最低限度，并给我们八。

583
00:31:31,666 --> 00:31:32,790
好吧，好吧，让我们来看看。

584
00:31:32,790 --> 00:31:35,190
我们会继续走下去的道路。

585
00:31:35,190 --> 00:31:38,490
我们再往左边的中间。

586
00:31:38,490 --> 00:31:40,560
我们往下看，我们看到有一个九岁​​。

587
00:31:40,560 --> 00:31:45,590
我们知道，我们将得到
至少有九个点按下去

588
00:31:45,590 --> 00:31:47,720
这中间的道路。

589
00:31:47,720 --> 00:31:52,110
而在这一点上，我们就可以暂停。

590
00:31:52,110 --> 00:31:56,910
我们可以说，看，我
知道在水平以上，

591
00:31:56,910 --> 00:32:01,160
我会得到不超过八个
通过走这方向点。

592
00:32:01,160 --> 00:32:05,670
但是，如果我去拦腰
路径，而不是离开路径，

593
00:32:05,670 --> 00:32:08,980
我会得到至少9分。

594
00:32:08,980 --> 00:32:13,590
>> 我的对手永远不会
让我走这中间道路。

595
00:32:13,590 --> 00:32:14,650
他们开始选择。

596
00:32:14,650 --> 00:32:18,140
而且他们会选择
路径向左朝8，

597
00:32:18,140 --> 00:32:23,650
而不是下来，对中间
什么是至少9分。

598
00:32:23,650 --> 00:32:25,334
所以在这一点上，我会停下来。

599
00:32:25,334 --> 00:32:26,500
我会说，你知道吗？

600
00:32:26,500 --> 00:32:29,990
我没有看任何
比较下来这个方向努力。

601
00:32:29,990 --> 00:32:32,270
因为我永远不会去那里。

602
00:32:32,270 --> 00:32:36,660
>> 我可以跳过那一个，
我可以跳过那六，

603
00:32:36,660 --> 00:32:39,720
因为这是永远也不会发生。

604
00:32:39,720 --> 00:32:42,470
所以，我会去，我会
考虑下一可能性。

605
00:32:42,470 --> 00:32:44,830
我去那里，我说，我看到了两种。

606
00:32:44,830 --> 00:32:47,125
我知道，如果我到了这里，我
将得到的至少两个。

607
00:32:47,125 --> 00:32:49,810

608
00:32:49,810 --> 00:32:50,470
好。

609
00:32:50,470 --> 00:32:51,520
我继续下去。

610
00:32:51,520 --> 00:32:52,440
我看到一个四。

611
00:32:52,440 --> 00:32:54,920
我知道我会得到至少有四个。

612
00:32:54,920 --> 00:32:57,200
仍然有很多的
四个和八个，虽然。

613
00:32:57,200 --> 00:32:58,454
所以，我继续下去。

614
00:32:58,454 --> 00:32:59,870
我低下头，我看到有一个。

615
00:32:59,870 --> 00:33:01,614
好吧，我知道，如果
我走上这条道路，

616
00:33:01,614 --> 00:33:03,280
我将能够选择的四个。

617
00:33:03,280 --> 00:33:06,540

618
00:33:06,540 --> 00:33:08,980
什么是我的对手会怎么做？

619
00:33:08,980 --> 00:33:12,310
东西之间给了我
八，东西给我四，

620
00:33:12,310 --> 00:33:14,730
和东西
让我至少九个，

621
00:33:14,730 --> 00:33:17,550
好了，他要给我四。

622
00:33:17,550 --> 00:33:20,110
我现在知道了
最顶端，我要去

623
00:33:20,110 --> 00:33:23,145
要能得到至少
四点了这个游戏。

624
00:33:23,145 --> 00:33:27,030

625
00:33:27,030 --> 00:33:30,900
>> α-β的整体思路
是切断部分树，

626
00:33:30,900 --> 00:33:32,530
我不看他们了。

627
00:33:32,530 --> 00:33:35,964
但它仍然看起来像我一直
看着很多树。

628
00:33:35,964 --> 00:33:36,880
让我们继续下去。

629
00:33:36,880 --> 00:33:38,305
现在，我们将下井下一个。

630
00:33:38,305 --> 00:33:39,680
唐氏在底部，我找一个。

631
00:33:39,680 --> 00:33:41,030
我知道我会得到至少一个。

632
00:33:41,030 --> 00:33:41,690
我继续寻找。

633
00:33:41,690 --> 00:33:42,625
>> 我找了三人。

634
00:33:42,625 --> 00:33:44,250
我知道我会得到至少有三个。

635
00:33:44,250 --> 00:33:44,840
我继续下去。

636
00:33:44,840 --> 00:33:45,660
我找了五位。

637
00:33:45,660 --> 00:33:49,760
我知道我要送五
如果我在这条道路下不来。

638
00:33:49,760 --> 00:33:52,580
而且我也知道再
我的对手，如果我

639
00:33:52,580 --> 00:33:55,510
选择中间
三大选择，

640
00:33:55,510 --> 00:34:01,440
他要给我
东西是五个或更少。

641
00:34:01,440 --> 00:34:02,150
>> 好。

642
00:34:02,150 --> 00:34:03,400
我可以继续去那里。

643
00:34:03,400 --> 00:34:06,470
我往下看，我
可以说，我该怎么

644
00:34:06,470 --> 00:34:08,239
拿到如果我往下走中间路线？

645
00:34:08,239 --> 00:34:09,909
我要得到的，还有三个在那里。

646
00:34:09,909 --> 00:34:12,080
我要得到的东西
这是至少三个。

647
00:34:12,080 --> 00:34:16,030
目前仍然之间的事情
三和五，所以我一直在寻找。

648
00:34:16,030 --> 00:34:20,203
哦，九，我肯定会
采取了三个。

649
00:34:20,203 --> 00:34:22,744
我要拿到至少有九个
如果我走这中间道路。

650
00:34:22,744 --> 00:34:25,530

651
00:34:25,530 --> 00:34:31,010
>> 现在，我的对手将停止，并说，
你看，有没有一点了。

652
00:34:31,010 --> 00:34:33,669
我知道我的
最小的对手，他的

653
00:34:33,669 --> 00:34:36,210
要给我的东西，是
小于或等于五，

654
00:34:36,210 --> 00:34:39,030
而非件事是
大于或等于9。

655
00:34:39,030 --> 00:34:39,530
我停下。

656
00:34:39,530 --> 00:34:40,779
我不看任何更多的那个。

657
00:34:40,779 --> 00:34:43,280
我继续下去。

658
00:34:43,280 --> 00:34:44,850
>> 我小看这一个。

659
00:34:44,850 --> 00:34:46,370
下到谷底，我发现一个六人。

660
00:34:46,370 --> 00:34:50,040
我知道我会得到至少六个。

661
00:34:50,040 --> 00:34:53,130
而我能做些什么？

662
00:34:53,130 --> 00:34:54,877
我可以停止。

663
00:34:54,877 --> 00:34:57,460
因为有之间的选择
东西是至少六个

664
00:34:57,460 --> 00:34:59,250
而东西是
不到五年，他的

665
00:34:59,250 --> 00:35:02,570
要给我的事
这是不到五年。

666
00:35:02,570 --> 00:35:04,779
现在我知道我要去
要得到完全的选择。

667
00:35:04,779 --> 00:35:06,195
我要拿到五次选择。

668
00:35:06,195 --> 00:35:08,980

669
00:35:08,980 --> 00:35:10,010
>> 我回去到顶部。

670
00:35:10,010 --> 00:35:11,450
我要去哪家
东西之间进行选择

671
00:35:11,450 --> 00:35:14,449
这是大于或等于4，
或东西是等于五？

672
00:35:14,449 --> 00:35:17,140
我要带的东西
这至少五个。

673
00:35:17,140 --> 00:35:20,490
我往下走过去的路，所有的
下到谷底的方式。

674
00:35:20,490 --> 00:35:21,260
有一个。

675
00:35:21,260 --> 00:35:23,410
好吧，至少我要拿到一分。

676
00:35:23,410 --> 00:35:24,427
我继续下去。

677
00:35:24,427 --> 00:35:25,760
二，哦，这是比一个好。

678
00:35:25,760 --> 00:35:27,100
我要拿到至少两个。

679
00:35:27,100 --> 00:35:28,610
我找了三人。

680
00:35:28,610 --> 00:35:31,450
我知道我会得到三个。

681
00:35:31,450 --> 00:35:34,690
>> 和上面的一点，
我的对手是怎么回事

682
00:35:34,690 --> 00:35:38,540
给我的东西的
小于或等于3。

683
00:35:38,540 --> 00:35:40,940
现在我可以停止。

684
00:35:40,940 --> 00:35:46,290
因为在我的选择是
能够得到一个五我的对手

685
00:35:46,290 --> 00:35:52,290
给我的东西不到三年，
我总是会拿这五。

686
00:35:52,290 --> 00:35:56,810
所以，我不评价说
树的底部都没有。

687
00:35:56,810 --> 00:35:59,470
>> 现在，这似乎很小。

688
00:35:59,470 --> 00:36:03,630
但是，当算术一点位，
大于和小于

689
00:36:03,630 --> 00:36:10,640
可以切掉整个地区
这种指数级增长的树，

690
00:36:10,640 --> 00:36:14,280
这导致了巨大的
储蓄，储蓄量

691
00:36:14,280 --> 00:36:17,630
这是足够大的，我
可以开始玩竞争力

692
00:36:17,630 --> 00:36:21,330
在更复杂的游戏。

693
00:36:21,330 --> 00:36:27,030
>> 好吧，如果我们看一下尺寸
和不同的游戏的复杂性，

694
00:36:27,030 --> 00:36:29,470
井字棋是我们简单的例子。

695
00:36:29,470 --> 00:36:32,150
我们三个了小板，三。

696
00:36:32,150 --> 00:36:36,030
我们得到的，最多，平均为
四种不同的选择

697
00:36:36,030 --> 00:36:38,440
因为我们去通过游戏。

698
00:36:38,440 --> 00:36:42,720
我们有地方约10至
第五个可能的不同叶子。

699
00:36:42,720 --> 00:36:45,200
而建设一个井字棋
播放器，好了，我们只是做了它。

700
00:36:45,200 --> 00:36:47,460
小菜一碟。

701
00:36:47,460 --> 00:36:49,890
>> 如果我们去到更多的东西
复杂，如连四。

702
00:36:49,890 --> 00:36:53,170
你还记得这个游戏，
你把小的令牌？

703
00:36:53,170 --> 00:36:58,490
这是一个六七板，
不是更大，仍

704
00:36:58,490 --> 00:37:00,770
有大约相同的分支
因素，因为井字棋。

705
00:37:00,770 --> 00:37:05,410
我有四个选择
在那里我可以把事情研究。

706
00:37:05,410 --> 00:37:10,760
但现在，我已经得到了很多
引出，10到21的功率。

707
00:37:10,760 --> 00:37:14,440
在这个时候，很容易
以至于我们解决这个问题的时候了。

708
00:37:14,440 --> 00:37:17,560
>> 跳棋，更complex--您
八牌上看到一个八。

709
00:37:17,560 --> 00:37:20,570
你只能在半
他们在任何时候，虽然。

710
00:37:20,570 --> 00:37:24,930
你已经有了一个分支
因素是关于2.8。

711
00:37:24,930 --> 00:37:28,160
好了，我们已经有一对夫妇
移动可以采取。

712
00:37:28,160 --> 00:37:33,870
你得约10至31叶，
大，大，和更大的空间。

713
00:37:33,870 --> 00:37:37,340
当我不得不通过搜索
那些越做越大的空间，

714
00:37:37,340 --> 00:37:42,220
这时候，像α-β和
能够切掉整个分支

715
00:37:42,220 --> 00:37:44,420
就显得至关重要。

716
00:37:44,420 --> 00:37:47,440
>> 现在，跳棋在1992年很容易。

717
00:37:47,440 --> 00:37:51,400
一种称为计算机程序
奇努克击败世界跳棋

718
00:37:51,400 --> 00:37:53,590
冠军马里昂·汀斯利。

719
00:37:53,590 --> 00:37:57,260
从那以后，没有
人类高手玩家

720
00:37:57,260 --> 00:38:02,290
之所以能够击败最好的
计算系统。

721
00:38:02,290 --> 00:38:06,570
如果我们考察一下国际象棋，现在
再次，我们八板有八个。

722
00:38:06,570 --> 00:38:09,870
但我们有更复杂
件，更复杂的动作。

723
00:38:09,870 --> 00:38:14,610
我们有大约一个分支因子
35，35，平均可能的行动

724
00:38:14,610 --> 00:38:20,030
我可以和状态
空间，若干叶

725
00:38:20,030 --> 00:38:28,950
是的成长到10到123电源，
数量巨大的可能性。

726
00:38:28,950 --> 00:38:35,570
>> 即使如此，现代的处理器
能够成功地做到这一点。

727
00:38:35,570 --> 00:38:43,900
1995年，然后在1997年，一台电脑
程序调用深蓝由IBM建造

728
00:38:43,900 --> 00:38:49,601
可以运行在一个巨大的超级计算机
击败目前的世界冠军，

729
00:38:49,601 --> 00:38:50,225
卡斯帕罗夫。

730
00:38:50,225 --> 00:38:54,000

731
00:38:54,000 --> 00:38:56,650
这是一个转折点。

732
00:38:56,650 --> 00:39:00,620
今天，虽然，相同的处理
电力坐在我的MacBook。

733
00:39:00,620 --> 00:39:04,180

734
00:39:04,180 --> 00:39:06,440
>> 处理速度保持
越走越快。

735
00:39:06,440 --> 00:39:09,500
我们可以评估越来越多
板越来越快。

736
00:39:09,500 --> 00:39:14,550
但更重要的是，我们有更好的
评价功能，更好地修剪

737
00:39:14,550 --> 00:39:15,460
的方法。

738
00:39:15,460 --> 00:39:19,560
所以，我们可以搜索
空间更加复杂地。

739
00:39:19,560 --> 00:39:22,350
该板的最大
游戏，我们能想到的，

740
00:39:22,350 --> 00:39:26,310
像围棋这
有一个19 19板，

741
00:39:26,310 --> 00:39:32,490
现在突然，我们过去点
其中，计算系统可以赢得。

742
00:39:32,490 --> 00:39:34,530
有没有计算
系统在那里

743
00:39:34,530 --> 00:39:38,880
可以击败一个专业棋手。

744
00:39:38,880 --> 00:39:45,000
关于最好的系统今天排名
排序好的业余水平。

745
00:39:45,000 --> 00:39:49,285
所以还是有相当多的出
那里，你不能去还。

746
00:39:49,285 --> 00:39:51,840

747
00:39:51,840 --> 00:39:55,360
>> 好吧，这些
传统的棋牌游戏，

748
00:39:55,360 --> 00:39:58,560
这些类型的系统，其中，我们
建立这个极小，不管它有

749
00:39:58,560 --> 00:40:06,300
α-β与否，这些算法的工作
因为有一定的限制。

750
00:40:06,300 --> 00:40:08,520
我们有完善的信息
关于世界。

751
00:40:08,520 --> 00:40:11,690
我们知道，所有的作品都是。

752
00:40:11,690 --> 00:40:13,570
世界是静态的。

753
00:40:13,570 --> 00:40:16,220
没有人获得移动
左右，而我是个

754
00:40:16,220 --> 00:40:20,640
坐在那里想，采取轮到我了。

755
00:40:20,640 --> 00:40:23,140
有一个动作空间的离散。

756
00:40:23,140 --> 00:40:26,900
我可以把我的棋子在这里，
或者，我可以把我的棋子在这里。

757
00:40:26,900 --> 00:40:30,520
我不能把我的棋子上
该行两个广场之间。

758
00:40:30,520 --> 00:40:34,430

759
00:40:34,430 --> 00:40:36,520
>> 最后，操作
是确定性的。

760
00:40:36,520 --> 00:40:39,790
我知道，如果我说，
车骑士三，

761
00:40:39,790 --> 00:40:44,660
我的车是要结束了在骑士
三，只要它是一个有效举措。

762
00:40:44,660 --> 00:40:47,830
有没有这方面的不确定性。

763
00:40:47,830 --> 00:40:52,490
现在，当我去更多
不同类型的游戏，

764
00:40:52,490 --> 00:40:55,960
我们必须打破这些假设。

765
00:40:55,960 --> 00:41:00,020
>> 如果我去的东西是什么
喜欢经典视频游戏？

766
00:41:00,020 --> 00:41:04,180
这里有一个选择的视频
游戏从雅达利2600。

767
00:41:04,180 --> 00:41:05,180
我有什么了吗？

768
00:41:05,180 --> 00:41:08,440
我有青蛙，空间
入侵者，陷阱和Pac-Man的。

769
00:41:08,440 --> 00:41:11,290

770
00:41:11,290 --> 00:41:14,840
什么样的环境
我必须在这里吗？

771
00:41:14,840 --> 00:41:16,900
其中这些假设
我必须打破？

772
00:41:16,900 --> 00:41:19,410

773
00:41:19,410 --> 00:41:21,570
>> 嗯，这取决于游戏。

774
00:41:21,570 --> 00:41:28,170
我会下棋的2600，和
它会成为像从前那样。

775
00:41:28,170 --> 00:41:33,020
对于大多数这些系统的，有
关于世界的完整的知识。

776
00:41:33,020 --> 00:41:36,300
有完全
确定性的行为。

777
00:41:36,300 --> 00:41:38,330
但通常情况下，世界
不再是静态的。

778
00:41:38,330 --> 00:41:41,970
也就是说，当我坐在那里
在等待的东西在移动。

779
00:41:41,970 --> 00:41:44,320
鬼都来接我。

780
00:41:44,320 --> 00:41:46,570
蝎子是继我的下方。

781
00:41:46,570 --> 00:41:48,880
太空侵略者
越来越近。

782
00:41:48,880 --> 00:41:54,020

783
00:41:54,020 --> 00:41:55,510
我们如何能做到针对这些？

784
00:41:55,510 --> 00:41:58,640

785
00:41:58,640 --> 00:42:02,790
>> 几年前，谷歌
曾要求项目

786
00:42:02,790 --> 00:42:12,030
DeepMind，他们培养了计算机
节目玩雅达利2600游戏。

787
00:42:12,030 --> 00:42:16,120
如果你认为这是不严重
企业，他们的研究结果

788
00:42:16,120 --> 00:42:19,920
发表在Nature，所以
只是好出版物

789
00:42:19,920 --> 00:42:22,500
因为你所能得到的。

790
00:42:22,500 --> 00:42:24,340
下面是他们如何执行。

791
00:42:24,340 --> 00:42:29,220
>> 他们有一个算法，坐
看着刚刚屏输入。

792
00:42:29,220 --> 00:42:34,080
它任何没有得到指令
关于游戏的规则。

793
00:42:34,080 --> 00:42:42,610
它本来是要弄清楚，
根据其成绩，以及它如何在做什么。

794
00:42:42,610 --> 00:42:46,560
这是用什么系统
所谓强化学习。

795
00:42:46,560 --> 00:42:48,380
也就是说，它看着它的得分。

796
00:42:48,380 --> 00:42:51,620
如果它得到了一个不错的成绩，它说，
我应该记住这些事情。

797
00:42:51,620 --> 00:42:53,310
我应该再做这些。

798
00:42:53,310 --> 00:42:56,450
如果它有一个不好的分数，它说，
我不应该再这样做这些事情。

799
00:42:56,450 --> 00:42:59,750

800
00:42:59,750 --> 00:43:03,430
>> 这是性能
这些训练有素的系统

801
00:43:03,430 --> 00:43:07,490
允许一玩
几个小时的每场比赛，

802
00:43:07,490 --> 00:43:12,490
相比较专业的玩家。

803
00:43:12,490 --> 00:43:19,670
因此，对于所有的游戏的
这条线的左侧，

804
00:43:19,670 --> 00:43:25,920
这个自学成才的电脑程序
跑赢了职业玩家。

805
00:43:25,920 --> 00:43:29,690
而对于一切的
正确的职业玩家

806
00:43:29,690 --> 00:43:30,920
仍然是最好的。

807
00:43:30,920 --> 00:43:34,040

808
00:43:34,040 --> 00:43:36,850
对于一些知道
一无所知的规则，

809
00:43:36,850 --> 00:43:43,020
一无所知的结构
游戏，这是令人印象深刻的表现。

810
00:43:43,020 --> 00:43:45,660
而这正是我们今天能够做到。

811
00:43:45,660 --> 00:43:50,239
>> OK，你说的，但如果我们
想想AI在游戏中，

812
00:43:50,239 --> 00:43:52,530
通常我们想到的
事情，我们实际上可以

813
00:43:52,530 --> 00:43:54,180
坐下来对战。

814
00:43:54,180 --> 00:43:58,760
如果我坐下来和我玩
星际争霸，还是我玩免费筛，

815
00:43:58,760 --> 00:44:01,870
计算机对手是
人控制的虫族，

816
00:44:01,870 --> 00:44:06,770
或控制其他文明。

817
00:44:06,770 --> 00:44:11,920
如何做到这些的球员
很难找到他们的举动？

818
00:44:11,920 --> 00:44:18,810
>> 那么，这些游戏的结构
大致相同的方式作为我们的下棋，

819
00:44:18,810 --> 00:44:22,250
这些游戏，我们会
共同呼吁四个X游戏，

820
00:44:22,250 --> 00:44:26,040
探索，expand--忘记的。

821
00:44:26,040 --> 00:44:26,980
他们是什么？

822
00:44:26,980 --> 00:44:32,150
探索，扩张，并熄灭，
我认为这是最后一个。

823
00:44:32,150 --> 00:44:36,060
但是，他们基本上
探索和征服的游戏。

824
00:44:36,060 --> 00:44:41,020
通常，计算机对手
有有有限的信息。

825
00:44:41,020 --> 00:44:45,486
他们不知道到底是什么
会在后面的战争的迷雾。

826
00:44:45,486 --> 00:44:47,735
他们不明白，看看有什么
你有你的库存。

827
00:44:47,735 --> 00:44:50,240

828
00:44:50,240 --> 00:44:52,800
>> 这里有一个环境是动态的。

829
00:44:52,800 --> 00:44:56,180
一切都在不断地变化。

830
00:44:56,180 --> 00:45:00,290
你不要坐下来，
迫不及待地把你的举动。

831
00:45:00,290 --> 00:45:02,810
但大多数事情还是离散的。

832
00:45:02,810 --> 00:45:04,200
我已经把我的城市在这里。

833
00:45:04,200 --> 00:45:06,750
或者，我已经把我的城市在这里。

834
00:45:06,750 --> 00:45:08,950
一切是确定性的。

835
00:45:08,950 --> 00:45:14,660
当我说，把我的单位在这里，我单位
移动这里，除非障碍物突然

836
00:45:14,660 --> 00:45:17,700
进场。

837
00:45:17,700 --> 00:45:21,610
现在，这还不是全部电脑
今天比赛是在那里。

838
00:45:21,610 --> 00:45:27,320
>> 如果我去和我玩一款第一人称类型
游戏，像小偷或辐射

839
00:45:27,320 --> 00:45:33,350
或者天际，或晕，现在
我的电脑对手

840
00:45:33,350 --> 00:45:37,860
是在那里有
一个非常不同的情况。

841
00:45:37,860 --> 00:45:40,020
他们再次，有限的信息。

842
00:45:40,020 --> 00:45:43,420
他们只能看到一个
某些字段的图。

843
00:45:43,420 --> 00:45:45,180
环境仍然是动态的。

844
00:45:45,180 --> 00:45:48,280
事情正在发生变化所有的时间。

845
00:45:48,280 --> 00:45:52,300
>> 但现在我有一个更
连续动作的空间。

846
00:45:52,300 --> 00:45:57,170
我可以只偷看一
点点出了门道。

847
00:45:57,170 --> 00:46:00,650
而一些游戏，我
行动是随机的。

848
00:46:00,650 --> 00:46:04,590
我去尝试跳过那道墙，
但我有一个失败的机会。

849
00:46:04,590 --> 00:46:08,280

850
00:46:08,280 --> 00:46:14,550
这些类型的游戏越来越近
和接近类型的控制器

851
00:46:14,550 --> 00:46:17,330
我们建立的机器人。

852
00:46:17,330 --> 00:46:21,050
>> 在机器人技术，我们必须假设
我们有限制的信息。

853
00:46:21,050 --> 00:46:23,070
我们有传感器
给我们介绍一下这个世界。

854
00:46:23,070 --> 00:46:25,860
我们有一个不断更新的，
动态环境。

855
00:46:25,860 --> 00:46:30,440
我们有一个世界中，空间
连续的，而不是离散的。

856
00:46:30,440 --> 00:46:36,260
而且我们的行动，当我们试图
其中，有一个失败的机会。

857
00:46:36,260 --> 00:46:40,960
而事实上，现代的游戏
控制器的最后一战的对手，

858
00:46:40,960 --> 00:46:48,690
或用于在天际那些的NPC，基本上
经营小机器人的架构。

859
00:46:48,690 --> 00:46:50,380
>> 他们感知世界。

860
00:46:50,380 --> 00:46:52,910
他们建造了世界的模型。

861
00:46:52,910 --> 00:46:57,950
它们计算基于一组的
目标，他们希望实现的目标。

862
00:46:57,950 --> 00:47:03,110
他们计划基础的行动
在他们所知道的。

863
00:47:03,110 --> 00:47:07,940
而这些都是完全一样的种
对我们构建机器人系统。

864
00:47:07,940 --> 00:47:11,420
因此，这些结构，以
把这个重新走到一起，

865
00:47:11,420 --> 00:47:14,500
往往是相当一致的。

866
00:47:14,500 --> 00:47:16,340
>> 因此，让我们看看我们是否能够看到。

867
00:47:16,340 --> 00:47:19,210
让我们回到我们
井字棋的例子。

868
00:47:19,210 --> 00:47:22,690
而我要问我的几个
博士后上来帮我。

869
00:47:22,690 --> 00:47:26,970
所以陈明，和Alessandro和
奥利维尔，如果你们会来。

870
00:47:26,970 --> 00:47:32,080

871
00:47:32,080 --> 00:47:35,440
而我会需要
一对夫妇的志愿者

872
00:47:35,440 --> 00:47:37,590
>> 好吧，我看到了一个手右上
中间有。

873
00:47:37,590 --> 00:47:39,965
让我带一个，有人
进一步在后面可能。

874
00:47:39,965 --> 00:47:40,881
好了，在那边。

875
00:47:40,881 --> 00:47:41,490
上来吧。

876
00:47:41,490 --> 00:47:44,190

877
00:47:44,190 --> 00:47:45,335
好吧。

878
00:47:45,335 --> 00:47:49,490
因此，让我们说盖了下来。

879
00:47:49,490 --> 00:48:03,700
如果你们会来的权利
回来在这里对我来说太棒了。

880
00:48:03,700 --> 00:48:06,580
>> 所以这是一个叫百特的机器人。

881
00:48:06,580 --> 00:48:10,880
和Baxter是一个机器人，这是一个
商业平台，设计

882
00:48:10,880 --> 00:48:13,030
由一家名为反思。

883
00:48:13,030 --> 00:48:16,580
而这个机器人被设计
对于小规模生产。

884
00:48:16,580 --> 00:48:19,265
但今天我们要
用它玩井字棋。

885
00:48:19,265 --> 00:48:21,930

886
00:48:21,930 --> 00:48:27,150
现在，这个机器人也未尝
这是比较独特的。

887
00:48:27,150 --> 00:48:32,950
因为如果我站在任何地方
接近标准的工厂自动化

888
00:48:32,950 --> 00:48:39,580
系统，我会非常严重
危险受伤。

889
00:48:39,580 --> 00:48:45,600
>> 巴克斯特，但是，被设计成
相对安全进行交互。

890
00:48:45,600 --> 00:48:48,680
所以，我可以把这个机器人。

891
00:48:48,680 --> 00:48:52,350
你可以看到这是一个有点
位灵活，因为它到处移动。

892
00:48:52,350 --> 00:48:57,250
我可以重新定位
在这里我想它去。

893
00:48:57,250 --> 00:49:03,410
现在，在一个正常的机器人系统，
我们将有一组接头在这里

894
00:49:03,410 --> 00:49:07,970
这将是直接
响应位置指令。

895
00:49:07,970 --> 00:49:13,180
他们不一定会在意
如果他们通过户外运动，

896
00:49:13,180 --> 00:49:15,555
或者，如果他们被感动
通过我的胸腔。

897
00:49:15,555 --> 00:49:18,410

898
00:49:18,410 --> 00:49:19,120
>> 好。

899
00:49:19,120 --> 00:49:22,090
并且通常，如果你
这里的工业体系，

900
00:49:22,090 --> 00:49:23,400
你会去远不及它。

901
00:49:23,400 --> 00:49:26,280
会有黄色
安全胶带周围的一切。

902
00:49:26,280 --> 00:49:28,310
这个系统有一个
稍有不同的设计

903
00:49:28,310 --> 00:49:32,130
要友好，更容易
人们互动，

904
00:49:32,130 --> 00:49:36,380
中，在每一个关节，有一个春天。

905
00:49:36,380 --> 00:49:39,110
而非控制
一个准确的位置，

906
00:49:39,110 --> 00:49:43,110
我们控制一定量的
扭矩，一定量的力，

907
00:49:43,110 --> 00:49:45,874
我们希望成为的那个春天。

908
00:49:45,874 --> 00:49:47,790
好了，所以让我
在这里把我们的志愿者。

909
00:49:47,790 --> 00:49:48,540
你好，你的名字是什么？

910
00:49:48,540 --> 00:49:49,010
>> 听众：路易斯。

911
00:49:49,010 --> 00:49:49,635
>> 演讲嘉宾：路易斯。

912
00:49:49,635 --> 00:49:50,490
很高兴见到你。

913
00:49:50,490 --> 00:49:50,990
和？

914
00:49:50,990 --> 00:49:51,610
>> 听众：大卫。

915
00:49:51,610 --> 00:49:51,960
>> 演讲嘉宾：大卫。

916
00:49:51,960 --> 00:49:52,550
很高兴见到你。

917
00:49:52,550 --> 00:49:54,508
如果你们会等
这里适合第二，

918
00:49:54,508 --> 00:49:56,420
我想给你
有机会做到这一点。

919
00:49:56,420 --> 00:50:00,610
所以这个机器人，如果你来了
如果你轻推就可以了，

920
00:50:00,610 --> 00:50:03,780
你会看到，
它移动一点点。

921
00:50:03,780 --> 00:50:06,349
如果你抓住它的权利
这里在手腕上刚

922
00:50:06,349 --> 00:50:09,390
其中，以上这些按钮，它
看起来你应该抓住的按钮，

923
00:50:09,390 --> 00:50:13,100
但抢正上方相反，你会
能够轻轻地操纵它

924
00:50:13,100 --> 00:50:14,545
通过空间。

925
00:50:14,545 --> 00:50:15,920
路易斯，你想给它一个尝试？

926
00:50:15,920 --> 00:50:19,465
所以给它一点点
推下手。

927
00:50:19,465 --> 00:50:23,190
然后，如果你把你的手指
在那里，并抓住它，

928
00:50:23,190 --> 00:50:24,807
因为它会动你呢。

929
00:50:24,807 --> 00:50:27,824

930
00:50:27,824 --> 00:50:29,365
好吧，你想给它一个尝试？

931
00:50:29,365 --> 00:50:29,980
上来吧。

932
00:50:29,980 --> 00:50:32,300
所以给它只是一个温柔
推那里开始。

933
00:50:32,300 --> 00:50:33,820
你可以感受到是什么感觉。

934
00:50:33,820 --> 00:50:40,060
然后，如果你抓住它那里，
你就可以操纵左右。

935
00:50:40,060 --> 00:50:41,280
>> 好。

936
00:50:41,280 --> 00:50:47,360
因此通常，这种机器人的会
用于小规模制造。

937
00:50:47,360 --> 00:50:50,980
而且我要正义之举这个手臂
淘汰下来的方式一点点在这里。

938
00:50:50,980 --> 00:50:55,750
但是今天，我们将使用
同样的井字棋播放系统

939
00:50:55,750 --> 00:50:59,520
根据我们先前建立极小。

940
00:50:59,520 --> 00:51:00,549
好不好？

941
00:51:00,549 --> 00:51:02,340
所以，你们是各
要玩游戏。

942
00:51:02,340 --> 00:51:04,210
路易斯，你会是第一个。

943
00:51:04,210 --> 00:51:05,920
让我抱起来这里进行了第二次。

944
00:51:05,920 --> 00:51:10,949
我要你站在正确的
在这里，只是让每个人都可以看到你。

945
00:51:10,949 --> 00:51:11,990
你们是不是在这里设置？

946
00:51:11,990 --> 00:51:13,120
>> 机器人：欢迎。

947
00:51:13,120 --> 00:51:15,910
让我们玩井字棋。

948
00:51:15,910 --> 00:51:20,860
之前，不要抓住你的令牌
我说，这是轮到你了。

949
00:51:20,860 --> 00:51:22,050
我开始游戏。

950
00:51:22,050 --> 00:51:27,900

951
00:51:27,900 --> 00:51:28,750
这是轮到我了。

952
00:51:28,750 --> 00:51:47,002

953
00:51:47,002 --> 00:51:50,210
演讲嘉宾：现在，如果你可以采取的一个
你的作品，并继续前进，并把它。

954
00:51:50,210 --> 00:51:51,446
机器人：它是轮到你了。

955
00:51:51,446 --> 00:51:53,430
[笑声]

956
00:51:53,430 --> 00:51:54,836
这是轮到我了。

957
00:51:54,836 --> 00:51:56,820
[笑声]

958
00:51:56,820 --> 00:52:12,196

959
00:52:12,196 --> 00:52:15,680
[笑声]

960
00:52:15,680 --> 00:52:16,570
轮到你了。

961
00:52:16,570 --> 00:52:21,397

962
00:52:21,397 --> 00:52:23,688
演讲嘉宾：人类是
你指望在这里，路易斯。

963
00:52:23,688 --> 00:52:27,440

964
00:52:27,440 --> 00:52:28,350
>> 机器人：它是轮到我了。

965
00:52:28,350 --> 00:52:44,810

966
00:52:44,810 --> 00:52:47,015
>> 演讲嘉宾：所以，巴克斯特
在这里成功地阻止。

967
00:52:47,015 --> 00:52:49,670

968
00:52:49,670 --> 00:52:52,480
>> 机器人：它是轮到你了。

969
00:52:52,480 --> 00:52:53,360
这是轮到我了。

970
00:52:53,360 --> 00:53:14,730

971
00:53:14,730 --> 00:53:16,810
轮到你了。

972
00:53:16,810 --> 00:53:17,760
这是轮到我了。

973
00:53:17,760 --> 00:53:21,330

974
00:53:21,330 --> 00:53:23,830
演讲嘉宾：我们将让巴克斯特
在这里完成了它的最后一步。

975
00:53:23,830 --> 00:53:36,622

976
00:53:36,622 --> 00:53:39,090
>> [笑声]

977
00:53:39,090 --> 00:53:40,480
>> 机器人：这是一个平局。

978
00:53:40,480 --> 00:53:42,030
我会赢得下一次。

979
00:53:42,030 --> 00:53:43,365
>> [笑声]

980
00:53:43,365 --> 00:53:45,210
>> 演讲嘉宾：好的，
非常感谢，路易。

981
00:53:45,210 --> 00:53:46,094
谢谢。

982
00:53:46,094 --> 00:53:46,980
你可以走这条路。

983
00:53:46,980 --> 00:53:49,759
>> 机器人：我开始游戏。

984
00:53:49,759 --> 00:53:51,800
演讲嘉宾：所以让我来解释一下
给你多一个小

985
00:53:51,800 --> 00:53:55,410
前位，我们在这里得到了复赛。

986
00:53:55,410 --> 00:53:57,200
究竟是怎么回事？

987
00:53:57,200 --> 00:53:59,430
因此，机器人有一个摄像头向上顶在这里。

988
00:53:59,430 --> 00:54:01,330
而且它低头看着板。

989
00:54:01,330 --> 00:54:04,470
而且它看到是否
它有一个红色的O或蓝色

990
00:54:04,470 --> 00:54:10,450
白色X.由于这些获得放置在
板，这是基本相同的输入

991
00:54:10,450 --> 00:54:13,890
我们将从读取
从我们的屏幕我们的数据结构。

992
00:54:13,890 --> 00:54:17,290
它的运行相同
极大极小算法是

993
00:54:17,290 --> 00:54:21,010
能够找到在哪​​里
把一个很好的象征。

994
00:54:21,010 --> 00:54:24,820
>> 然后我们给有关的命令
在这里我们想令牌放置。

995
00:54:24,820 --> 00:54:26,120
手臂动了。

996
00:54:26,120 --> 00:54:31,750
它采用真空夹具适用
一些吸引到木件，

997
00:54:31,750 --> 00:54:35,240
把它捡起来，将其移动到右边
现货方面，然后释放抽吸

998
00:54:35,240 --> 00:54:36,950
并把它。

999
00:54:36,950 --> 00:54:38,990
好吧，我们要去
给它多一枪

1000
00:54:38,990 --> 00:54:40,930
一个稍微聪明的球员在这里。

1001
00:54:40,930 --> 00:54:42,290
你准备好了吗？

1002
00:54:42,290 --> 00:54:46,150
好吧，如果你站在直到
这里为A--出现这样的局面

1003
00:54:46,150 --> 00:54:47,955
所以你可以看到大家。

1004
00:54:47,955 --> 00:54:48,830
然后[听不清]。

1005
00:54:48,830 --> 00:54:49,330
>> 机器人：它是轮到我了。

1006
00:54:49,330 --> 00:54:50,455
>> 演讲嘉宾：百特将启动。

1007
00:54:50,455 --> 00:55:10,750

1008
00:55:10,750 --> 00:55:11,730
轮到你了。

1009
00:55:11,730 --> 00:55:16,490

1010
00:55:16,490 --> 00:55:17,520
这是轮到我了。

1011
00:55:17,520 --> 00:55:38,740

1012
00:55:38,740 --> 00:55:39,690
轮到你了。

1013
00:55:39,690 --> 00:55:46,330

1014
00:55:46,330 --> 00:55:47,165
这是轮到我了。

1015
00:55:47,165 --> 00:56:01,252

1016
00:56:01,252 --> 00:56:06,192
>> [笑声]

1017
00:56:06,192 --> 00:56:08,542
>> 演讲嘉宾：[WHISPERING]刚
让他继续前进，取得胜利。

1018
00:56:08,542 --> 00:56:09,500
机器人：它是轮到你了。

1019
00:56:09,500 --> 00:56:15,099

1020
00:56:15,099 --> 00:56:15,890
演讲嘉宾：这是确定的。

1021
00:56:15,890 --> 00:56:20,390

1022
00:56:20,390 --> 00:56:21,360
>> 机器人：它是轮到我了。

1023
00:56:21,360 --> 00:56:24,825

1024
00:56:24,825 --> 00:56:26,805
>> [笑声]

1025
00:56:26,805 --> 00:56:42,650

1026
00:56:42,650 --> 00:56:43,510
>> 我赢了。

1027
00:56:43,510 --> 00:56:45,620
>> [笑声]

1028
00:56:45,620 --> 00:56:46,595
>> 我开始游戏。

1029
00:56:46,595 --> 00:56:48,261
>> 演讲嘉宾：好的，非常感谢你。

1030
00:56:48,261 --> 00:56:50,180

1031
00:56:50,180 --> 00:56:55,590
好吧，我想我们还有时间
多了一个优秀的井字棋的球员，

1032
00:56:55,590 --> 00:57:00,490
谁可以把这个事情
匹配，谁知道他们在做什么。

1033
00:57:00,490 --> 00:57:03,010
>> [笑声]

1034
00:57:03,010 --> 00:57:05,560
>> 谁是要在这里是我们的冠军吗？

1035
00:57:05,560 --> 00:57:08,110
好吧，你的朋友自告奋勇你。

1036
00:57:08,110 --> 00:57:11,190
这对我来说不够好。

1037
00:57:11,190 --> 00:57:12,194
再告诉我你的名字。

1038
00:57:12,194 --> 00:57:12,860
听众：塔米尔。

1039
00:57:12,860 --> 00:57:14,193
演讲嘉宾：塔米尔，很高兴见到你。

1040
00:57:14,193 --> 00:57:19,270
好吧，再次，我们打算把你
直到这里，所以每个人都可以看到你。

1041
00:57:19,270 --> 00:57:22,070
你是我们的代表
在这场比赛了。

1042
00:57:22,070 --> 00:57:24,540
巴克斯特是哦，呵呵。

1043
00:57:24,540 --> 00:57:26,300
还是遗憾，一个OH和一个。

1044
00:57:26,300 --> 00:57:27,490
而它给你在这里。

1045
00:57:27,490 --> 00:57:29,340
百特将获得先动，虽然。

1046
00:57:29,340 --> 00:57:30,435
所以。

1047
00:57:30,435 --> 00:57:31,310
机器人：它是轮到我了。

1048
00:57:31,310 --> 00:57:45,226

1049
00:57:45,226 --> 00:57:48,208
>> [笑声]

1050
00:57:48,208 --> 00:57:52,720

1051
00:57:52,720 --> 00:57:55,780
>> 轮到你了。

1052
00:57:55,780 --> 00:57:56,845
这是轮到我了。

1053
00:57:56,845 --> 00:58:18,130

1054
00:58:18,130 --> 00:58:18,965
轮到你了。

1055
00:58:18,965 --> 00:58:28,751

1056
00:58:28,751 --> 00:58:30,248
这是轮到我了。

1057
00:58:30,248 --> 00:58:51,210

1058
00:58:51,210 --> 00:58:52,160
轮到你了。

1059
00:58:52,160 --> 00:59:00,854

1060
00:59:00,854 --> 00:59:03,365
>> [笑声]

1061
00:59:03,365 --> 00:59:04,240
机器人：它是轮到我了。

1062
00:59:04,240 --> 00:59:06,930
演讲嘉宾：这是一个很大困难时，
你站在这儿，伙计。

1063
00:59:06,930 --> 00:59:19,400

1064
00:59:19,400 --> 00:59:21,840
[笑声]

1065
00:59:21,840 --> 00:59:26,730

1066
00:59:26,730 --> 00:59:29,054
机器人：你们人类是那么容易被击败。

1067
00:59:29,054 --> 00:59:30,803
[笑声及掌声]

1068
00:59:30,803 --> 00:59:31,886
演讲嘉宾：非常感谢。

1069
00:59:31,886 --> 00:59:34,692
机器人：我赢了。

1070
00:59:34,692 --> 00:59:35,400
我开始游戏。

1071
00:59:35,400 --> 00:59:39,500
>> 演讲嘉宾：好的，十分感谢非常
太多的奥利维尔，并亚历山德罗，

1072
00:59:39,500 --> 00:59:41,616
和陈明。

1073
00:59:41,616 --> 00:59:45,600
>> [掌声]

1074
00:59:45,600 --> 00:59:47,040
>> 我想提出最后一点。

1075
00:59:47,040 --> 00:59:51,630
所以巴克斯特在非常
到此为止，被骗。

1076
00:59:51,630 --> 00:59:54,160

1077
00:59:54,160 --> 00:59:56,310
这是出乎意料的。

1078
00:59:56,310 --> 01:00:00,440
一个梦幻般的
有关AI的事情是，我们

1079
01:00:00,440 --> 01:00:05,070
做工作，AI，使我们能够建立
真的很有趣，智能化

1080
01:00:05,070 --> 01:00:06,930
设备。

1081
01:00:06,930 --> 01:00:10,130
但是，我们也爱做的工作
因为它告诉我们什么

1082
01:00:10,130 --> 01:00:13,940
有关如何人类是聪明的。

1083
01:00:13,940 --> 01:00:17,280
>> 人们所喜爱的
从我的实验室研究是

1084
01:00:17,280 --> 01:00:23,660
看会发生什么时
机器意外作弊。

1085
01:00:23,660 --> 01:00:27,070
我们这样做原本不
百特玩井字棋，

1086
01:00:27,070 --> 01:00:30,340
但有一个名为淖较小的机器人，
谁发挥剪刀，石头，布。

1087
01:00:30,340 --> 01:00:33,010

1088
01:00:33,010 --> 01:00:35,800
有时后
打很多很多

1089
01:00:35,800 --> 01:00:41,580
无聊的剪刀，石头，布的游戏，
机器人将抛出一个手势，

1090
01:00:41,580 --> 01:00:48,616
输了，然后突然改变
它的姿态，说，我赢了。

1091
01:00:48,616 --> 01:00:50,480
>> [笑声]

1092
01:00:50,480 --> 01:00:56,090
>> 现在，有时我们也不得不机器人，
只是作为一个控制，抛出一个手势，

1093
01:00:56,090 --> 01:01:01,270
赢了，并改变其姿态
输了，丢了比赛，

1094
01:01:01,270 --> 01:01:04,070
作弊是为了减肥。

1095
01:01:04,070 --> 01:01:07,540
这是几乎没有引人注目。

1096
01:01:07,540 --> 01:01:09,890
该秘籍机器人
为了赢得人们

1097
01:01:09,890 --> 01:01:14,660
到，就好像它是响应
出去找他们，喜欢它

1098
01:01:14,660 --> 01:01:17,690
正在积极寻求他们的破坏。

1099
01:01:17,690 --> 01:01:19,210
>> [笑声]

1100
01:01:19,210 --> 01:01:20,990
>> 它成为一个代理。

1101
01:01:20,990 --> 01:01:21,840
这就像一个人。

1102
01:01:21,840 --> 01:01:23,970
它有信念和意图。

1103
01:01:23,970 --> 01:01:27,470
而且这不是善意。

1104
01:01:27,470 --> 01:01:33,790
和机器人抛出
游戏只是故障。

1105
01:01:33,790 --> 01:01:36,990
这只是一个损坏的设备。

1106
01:01:36,990 --> 01:01:41,405
让我告诉你一些例子
的，从我们的一些参与者。

1107
01:01:41,405 --> 01:01:43,990

1108
01:01:43,990 --> 01:01:45,600
因此，这里的作弊是为了减肥。

1109
01:01:45,600 --> 01:01:46,266
>> [视频回放]

1110
01:01:46,266 --> 01:01:47,010
 -  [听不清]获胜。

1111
01:01:47,010 --> 01:01:49,550
让我们玩。

1112
01:01:49,550 --> 01:01:50,538
>> -Wait，是什么？

1113
01:01:50,538 --> 01:01:54,490

1114
01:01:54,490 --> 01:01:55,352
>>  -  [听不清]获胜。

1115
01:01:55,352 --> 01:01:58,280
让我们玩。

1116
01:01:58,280 --> 01:01:59,400
>> [听不清]获胜。

1117
01:01:59,400 --> 01:02:02,290
让我们玩。

1118
01:02:02,290 --> 01:02:05,490
>> 演讲嘉宾：这里的作弊取胜。

1119
01:02:05,490 --> 01:02:06,438
>>  - 是的，我赢了。

1120
01:02:06,438 --> 01:02:07,394
让我们玩。

1121
01:02:07,394 --> 01:02:08,828
>>  - 你不能这样做。

1122
01:02:08,828 --> 01:02:10,740
>> [笑声]

1123
01:02:10,740 --> 01:02:12,174

1124
01:02:12,174 --> 01:02:13,979
>>  - 是的，我赢了。

1125
01:02:13,979 --> 01:02:14,520
-你作弊。

1126
01:02:14,520 --> 01:02:17,990

1127
01:02:17,990 --> 01:02:20,010
现在，您被骗。

1128
01:02:20,010 --> 01:02:21,140
>>  - 是的，我赢了。

1129
01:02:21,140 --> 01:02:22,940
>>  - 嘿，你骗子。

1130
01:02:22,940 --> 01:02:26,670
你欺骗，超级骗子。

1131
01:02:26,670 --> 01:02:27,650
>> [结束播放]

1132
01:02:27,650 --> 01:02:31,130
>> 演讲嘉宾：这些不同
反应迅速

1133
01:02:31,130 --> 01:02:34,890
改变我们的感知设备。

1134
01:02:34,890 --> 01:02:36,780
这是否意味着，
我们特意打造

1135
01:02:36,780 --> 01:02:40,370
该作弊，因为这是机器
我们能做的最好的工程？

1136
01:02:40,370 --> 01:02:44,680
没有，但它告诉我们什么
真正有趣的人。

1137
01:02:44,680 --> 01:02:49,710
这件事欺骗了你和
偷了你的胜利，这是

1138
01:02:49,710 --> 01:02:53,660
东西是活的，这是
动画，那是出去找你。

1139
01:02:53,660 --> 01:02:54,680
它具有的精神状态。

1140
01:02:54,680 --> 01:02:55,400
它有信念。

1141
01:02:55,400 --> 01:02:57,170
它的意图。

1142
01:02:57,170 --> 01:03:01,540
>> 这件事，手中的
游戏中你，那不是。

1143
01:03:01,540 --> 01:03:04,670
这只是发生故障。

1144
01:03:04,670 --> 01:03:08,900
这是在许多方面它为什么
易投掷游戏的孩子。

1145
01:03:08,900 --> 01:03:12,050
但是，如果你试图欺骗他们
和排序的取得胜利

1146
01:03:12,050 --> 01:03:15,200
如果，你知道的，只是为了缩短
比赛中，他们会抓住你的时候了。

1147
01:03:15,200 --> 01:03:19,040

1148
01:03:19,040 --> 01:03:23,140
这些种的效果是
我们看到走出来的AI，

1149
01:03:23,140 --> 01:03:26,490
他们教给我们很多关于自己。

1150
01:03:26,490 --> 01:03:28,076
>> 好吧，这就是它的今天。

1151
01:03:28,076 --> 01:03:30,450
非常感谢大卫，
哈佛制作团队

1152
01:03:30,450 --> 01:03:32,350
对下来。

1153
01:03:32,350 --> 01:03:33,820
>> [掌声]

1154
01:03:33,820 --> 01:03:36,760

1155
01:03:36,760 --> 01:03:41,840
>> 我们会看到你的测验之一，
然后一最后一次演讲。

1156
01:03:41,840 --> 01:03:43,025
祝你有美好的一天。

1157
01:03:43,025 --> 01:03:44,965
>> [掌声]

1158
01:03:44,965 --> 01:03:48,360

1159
01:03:48,360 --> 01:03:51,825
>> [音乐播放]

1160
01:03:51,825 --> 01:03:54,950
大卫·马兰：好吧，我们可能需要
引入加密一些，

1161
01:03:54,950 --> 01:03:55,450
对？

1162
01:03:55,450 --> 01:03:58,650
因为那么头
这些HTTP请求将

1163
01:03:58,650 --> 01:04:01,530
炒使任何人
试图嗅出你的流量

1164
01:04:01,530 --> 01:04:03,400
实际上不会能够看到它们。

1165
01:04:03,400 --> 01:04:05,254
那么，有什么办法解决这个问题？

1166
01:04:05,254 --> 01:04:07,920
好了，我们需要真正引入
加密入公式，

1167
01:04:07,920 --> 01:04:11,010
这样，当该人是
从A发送数据给B，

1168
01:04:11,010 --> 01:04:12,390
我们可以安全地send--

1169
01:04:12,390 --> 01:04:14,590
>> [笑声]

1170
01:04:14,590 --> 01:04:19,530
>> 在一个方式中的信息，该
攻击者无法，其实，看到它。