1
00:00:00,000 --> 00:00:03,416
>> [音乐播放]

2
00:00:03,416 --> 00:00:05,860

3
00:00:05,860 --> 00:00:08,180
>> 脑SCASSELLATI：欢迎
到CS50 AI系列。

4
00:00:08,180 --> 00:00:12,600
我的名字是Scass，今天我们要去
说说推荐系统。

5
00:00:12,600 --> 00:00:15,780
现在，推荐系统声音
像那种一个奇怪的名字。

6
00:00:15,780 --> 00:00:18,630
这听起来像也许它应该
是推荐系统，

7
00:00:18,630 --> 00:00:21,290
样的，我同意你的看法。

8
00:00:21,290 --> 00:00:26,110
但是，这些都是帮助系统
选择了类似的事情，只要

9
00:00:26,110 --> 00:00:28,210
您选择网上的东西。

10
00:00:28,210 --> 00:00:32,119
Netflix公司，例如会建议其他
电影，你可能想要观看。

11
00:00:32,119 --> 00:00:36,660
或者潘多拉会建议不同
歌曲，你可能要听。

12
00:00:36,660 --> 00:00:40,940
亚马逊将提出什么样的
其他的产品则可能需要购买。

13
00:00:40,940 --> 00:00:43,520
Facebook的甚至会建议
一些其他的朋友

14
00:00:43,520 --> 00:00:45,440
你可能需要添加。

15
00:00:45,440 --> 00:00:49,800
每个系统进行操作使用
相同的基本算法种类的，

16
00:00:49,800 --> 00:00:52,520
而这正是我们
要谈论今天。

17
00:00:52,520 --> 00:00:56,860
>> 现在，这些算法
令人惊讶的大企业。

18
00:00:56,860 --> 00:01:01,130
Netflix公司几年前在
2009年提供了$ 1百万

19
00:01:01,130 --> 00:01:07,240
如果你能提高自己的奖金
推荐系统，只需10％。

20
00:01:07,240 --> 00:01:11,960
有10％，不过，表示
大量的业务。

21
00:01:11,960 --> 00:01:15,330
估计是难以
来的，但很多人

22
00:01:15,330 --> 00:01:19,050
相信这些建议
一个在线采购系统

23
00:01:19,050 --> 00:01:25,729
系统像亚马逊导致地方
在10％和25％的增加收入。

24
00:01:25,729 --> 00:01:27,770
所以，你可以想像
种量，你是

25
00:01:27,770 --> 00:01:32,860
说起当我们思考
即使这些小的算法。

26
00:01:32,860 --> 00:01:35,200
>> 因此，让我们得到一些例子。

27
00:01:35,200 --> 00:01:38,460
它是如何，这些
系统真的有用吗？

28
00:01:38,460 --> 00:01:40,773
有两种基本
种的算法的

29
00:01:40,773 --> 00:01:45,050
在作怪，当我们谈论
生成建议。

30
00:01:45,050 --> 00:01:48,650
第一个的人被称为
基于内容的过滤。

31
00:01:48,650 --> 00:01:53,410
而基于内容的过滤依赖
于项之间的相似

32
00:01:53,410 --> 00:02:00,370
自己，那就是两部电影之间
两首歌曲或两个购买的物品。

33
00:02:00,370 --> 00:02:03,190
我们将使用电影
作为一个例子，但本

34
00:02:03,190 --> 00:02:07,850
可以适用，真的，任何类型的
的对象，我们要寻找的。

35
00:02:07,850 --> 00:02:13,330
>> 所以，如果我想一些
从去年的电影，

36
00:02:13,330 --> 00:02:16,799
只见里面出与
我的孩子们，他们喜欢它。

37
00:02:16,799 --> 00:02:17,840
但我们也有一个选择。

38
00:02:17,840 --> 00:02:21,350
我们可能已经看到喽罗，
我们可以看到ULTRON的年龄，

39
00:02:21,350 --> 00:02:24,850
或者，我们可以看到
蚂蚁人在影院上映。

40
00:02:24,850 --> 00:02:27,580
>> 对于任何这些
电影中，我们可以想像

41
00:02:27,580 --> 00:02:33,320
产生的特征的列表或
有关这些不同的电影品质。

42
00:02:33,320 --> 00:02:37,190
因此，例如，我可以考虑
其中，这些电影是动画。

43
00:02:37,190 --> 00:02:39,960
那么，无论是由内而外
和喽罗是动画。

44
00:02:39,960 --> 00:02:44,140
ULTRON的年龄都没有，也没有
蚂蚁人都是动画电影。

45
00:02:44,140 --> 00:02:47,040
我能想象建设
起来的结构中，一个表，该表

46
00:02:47,040 --> 00:02:49,440
列出这些属性。

47
00:02:49,440 --> 00:02:51,790
他们是否动画或不？

48
00:02:51,790 --> 00:02:54,780
然后，我可以添加更多
功能，以该表

49
00:02:54,780 --> 00:02:58,380
通过添加更多的行成这种结构。

50
00:02:58,380 --> 00:03:00,970
我可以问是否
不，他们是奇迹的电影。

51
00:03:00,970 --> 00:03:04,010
那么，由内而外和喽罗
没有奇迹的电影，

52
00:03:04,010 --> 00:03:06,715
ULTRON和Ant人的年龄肯定是。

53
00:03:06,715 --> 00:03:09,100
>> 而且我可以问任何种类的
不同质量的

54
00:03:09,100 --> 00:03:12,080
我想，任何种功能
这可能是对我很重要。

55
00:03:12,080 --> 00:03:13,440
他们有一个超级大坏蛋？

56
00:03:13,440 --> 00:03:16,700
那么，有没有超级大坏蛋里面
退房手续，但也有那些在喽罗

57
00:03:16,700 --> 00:03:19,990
和在，很明显，
2超级英雄电影。

58
00:03:19,990 --> 00:03:23,900
>> 我还可以问之类的东西，那么，
确实，他们通过Bechdel测试？

59
00:03:23,900 --> 00:03:27,280
是否有两个命名
女性角色谁

60
00:03:27,280 --> 00:03:30,550
花一些显著量
有一个谈话时间

61
00:03:30,550 --> 00:03:34,400
不涉及人的中投？

62
00:03:34,400 --> 00:03:39,870
那么，在这种情况下，由内向外传递
测试中，喽罗失败，ULTRON的年龄

63
00:03:39,870 --> 00:03:42,990
通过测试，和蚂蚁人失败。

64
00:03:42,990 --> 00:03:45,020
这些功能中的任何一个
我能想到的

65
00:03:45,020 --> 00:03:48,660
作为对某些人来说很重要。

66
00:03:48,660 --> 00:03:52,000
>> 我还可以问之类的东西都
在这些影片有没有人说

67
00:03:52,000 --> 00:03:57,190
来自校友比方说，公园和
娱乐，我最喜欢的节目之一。

68
00:03:57,190 --> 00:04:00,540
好了，里面走出了艾米
波勒，这是一个校友。

69
00:04:00,540 --> 00:04:01,530
才是最重要。

70
00:04:01,530 --> 00:04:04,110
乔恩哈姆是喽罗。

71
00:04:04,110 --> 00:04:08,600
保罗陆克文是蚂蚁人，但没有人
在ULTRON的年龄在公园和所需物品

72
00:04:08,600 --> 00:04:10,150
为好。

73
00:04:10,150 --> 00:04:12,990
所以，我可以建立起来的这个名单
功能，并且真正做到了

74
00:04:12,990 --> 00:04:14,710
约看电影什么。

75
00:04:14,710 --> 00:04:17,329
它们可能是什么
纵横比他们被射中，

76
00:04:17,329 --> 00:04:21,630
它可能是多少个座位，他们
在他们的首个周末售出。

77
00:04:21,630 --> 00:04:25,630
我想任何功能
生成我可以把这个表。

78
00:04:25,630 --> 00:04:29,600
>> 现在，在这种情况下，我已经建立
所有类金银价值，

79
00:04:29,600 --> 00:04:33,700
是或否，通过或失败，
但它们可以是任何东西。

80
00:04:33,700 --> 00:04:36,690
他们可以是任意值。

81
00:04:36,690 --> 00:04:39,070
对于基于内容过滤，
我们要做些什么

82
00:04:39,070 --> 00:04:42,810
是我们要考虑的
此表中的两列

83
00:04:42,810 --> 00:04:45,660
，看看他们是如何的相似。

84
00:04:45,660 --> 00:04:48,640
因此，举例来说，如果我
去看了由内而外，

85
00:04:48,640 --> 00:04:53,640
我可能会问，有什么其他电影
我可能愿意去看看。

86
00:04:53,640 --> 00:04:56,890
也就是说，什么愿意
花我的钱去看看。

87
00:04:56,890 --> 00:05:00,310
我可以通过只考虑比较这
两列，一列从内而外

88
00:05:00,310 --> 00:05:03,300
和一个来自任何的
其他电影，只是看到

89
00:05:03,300 --> 00:05:06,210
有多少他们的特点相匹配。

90
00:05:06,210 --> 00:05:09,660
所以，如果我比较内而外
与喽罗，嗯，有

91
00:05:09,660 --> 00:05:10,910
三件事这里比赛。

92
00:05:10,910 --> 00:05:16,200
他们都是动态的，他们都没有
是奇迹的电影，两者的

93
00:05:16,200 --> 00:05:18,420
有公园和所需物品的校友。

94
00:05:18,420 --> 00:05:20,420
所以，我可以计数如何
很多场比赛有，

95
00:05:20,420 --> 00:05:22,640
并且在这种情况下，存在会是3。

96
00:05:22,640 --> 00:05:26,450
>> 如果我再比较而外
与假设ULTRON的年龄，

97
00:05:26,450 --> 00:05:28,430
我可以看看在列表中向下
并说，嗯，有

98
00:05:28,430 --> 00:05:30,140
匹配有只有一件事。

99
00:05:30,140 --> 00:05:34,560
他们都通过了德尔测试，所以
这将是一分。

100
00:05:34,560 --> 00:05:36,770
而由内而外的
和蚂蚁人，我再次

101
00:05:36,770 --> 00:05:41,420
可能是由于线路比较线多少
事情他们两个人之间的匹配。

102
00:05:41,420 --> 00:05:43,060
那么，一个人的动画，一个人的不是。

103
00:05:43,060 --> 00:05:44,970
一个是一个奇迹的电影，人们不是。

104
00:05:44,970 --> 00:05:47,280
一个人的得到了一个超级大坏蛋，
另一个没有。

105
00:05:47,280 --> 00:05:49,480
一通柏克德
测试，一次失败了，

106
00:05:49,480 --> 00:05:54,450
但他们都有公园和所需物品的校友，
如此反复，它得到一分。

107
00:05:54,450 --> 00:05:58,300
>> 所以，如果我正在寻找电影
在类似于内而外，

108
00:05:58,300 --> 00:06:02,170
我可以寻找具有电影
得分最高的这个内容中

109
00:06:02,170 --> 00:06:03,952
过滤方案。

110
00:06:03,952 --> 00:06:05,660
因此，在这种情况下，我
会考虑喽罗

111
00:06:05,660 --> 00:06:08,330
要更加密切和
可能是什么

112
00:06:08,330 --> 00:06:13,250
我会花钱去看
比ULTRON或蚂蚁人的年龄。

113
00:06:13,250 --> 00:06:16,150
>> 这些基于内容的
过滤系统依赖只是

114
00:06:16,150 --> 00:06:18,670
上的性质
电影，所以我

115
00:06:18,670 --> 00:06:21,930
只需通过了解建立这些
一些有关产品

116
00:06:21,930 --> 00:06:23,500
我有。

117
00:06:23,500 --> 00:06:26,050
我可以使用任何类型的
的功能，我想，

118
00:06:26,050 --> 00:06:28,400
我可以建立更多
复杂的功能，

119
00:06:28,400 --> 00:06:33,060
涉及到更复杂的测试
质量作为我走。

120
00:06:33,060 --> 00:06:39,080
事实上，我甚至可以查看该表
不是作为一个静态的对象，

121
00:06:39,080 --> 00:06:43,110
而作为维
在较大的状态空间。

122
00:06:43,110 --> 00:06:46,295
我可以开始谈论
不同的电影之间的距离。

123
00:06:46,295 --> 00:06:49,300

124
00:06:49,300 --> 00:06:51,050
这些都是事
我们知道他们是如何

125
00:06:51,050 --> 00:06:55,860
做使用多种数据结构
我们已经看到在CS50。

126
00:06:55,860 --> 00:06:59,180
所以，我能想象建设
的数据结构的电影。

127
00:06:59,180 --> 00:07:02,390
还有，我已经一个结构
构建所谓的电影，

128
00:07:02,390 --> 00:07:04,369
并且它具有在其5布尔条目。

129
00:07:04,369 --> 00:07:07,160
难道是动画，它是一个奇迹
电影，它有一个超级大坏蛋，

130
00:07:07,160 --> 00:07:11,047
它通过Bechdel考验，
是否有公园和Rec校友呢？

131
00:07:11,047 --> 00:07:12,880
与每个这些是一个
数据结构，我

132
00:07:12,880 --> 00:07:16,330
可以占用该特定的电影。

133
00:07:16,330 --> 00:07:20,090
>> 然后计算是否将两个
电影是相似与否，

134
00:07:20,090 --> 00:07:23,330
他们的成绩是，我可以
写出一组伪那

135
00:07:23,330 --> 00:07:25,120
生成相同的功能。

136
00:07:25,120 --> 00:07:30,100
也就是说，考虑到一些电影M1，我可以
找到最类似电影到它

137
00:07:30,100 --> 00:07:32,430
通过以下的伪代码。

138
00:07:32,430 --> 00:07:37,040
我认为这是最好的
进球我发现系统，

139
00:07:37,040 --> 00:07:39,920
我已经找到了最好的对比。

140
00:07:39,920 --> 00:07:41,890
对于每一个其他的电影
我会去通过，

141
00:07:41,890 --> 00:07:44,920
我将设置一个匹配率等于0。

142
00:07:44,920 --> 00:07:47,920
我会去通过
电影，M1，电影

143
00:07:47,920 --> 00:07:51,500
我开始，我会检查
每一个功能

144
00:07:51,500 --> 00:07:53,650
他们有看
如果有一个匹配。

145
00:07:53,650 --> 00:07:56,460
如果有一场比赛，我会
增加比赛得分。

146
00:07:56,460 --> 00:08:00,480
而如果在结束比赛分数，
我已经比目前最好的更好

147
00:08:00,480 --> 00:08:03,310
进球，那我就
请记住，最好的成绩，

148
00:08:03,310 --> 00:08:05,820
这是最好的比赛，我有。

149
00:08:05,820 --> 00:08:09,450
最后，无论电影
坐在最佳匹配，

150
00:08:09,450 --> 00:08:12,580
这是最接近
我已经能来。

151
00:08:12,580 --> 00:08:14,890
因此，这些内容的基础
过滤系统，

152
00:08:14,890 --> 00:08:16,900
它们都具有这样的基本结构。

153
00:08:16,900 --> 00:08:20,910
他们依靠项目
问题并没有什么

154
00:08:20,910 --> 00:08:24,590
任何用户首选项。

155
00:08:24,590 --> 00:08:29,010
>> 我们在使用其他机制
为了建立推荐系统

156
00:08:29,010 --> 00:08:31,790
被称为协同过滤。

157
00:08:31,790 --> 00:08:36,520
协同过滤依赖
而不是对象本身的品质，

158
00:08:36,520 --> 00:08:40,010
但如何人，其他
网友认为，他们怎么样了

159
00:08:40,010 --> 00:08:43,370
针对这些相同的对象。

160
00:08:43,370 --> 00:08:48,720
因此，要继续我的电影的例子，
我可能会采取一帮朋友

161
00:08:48,720 --> 00:08:53,180
并调查他们关于是否
他们不喜欢特别的电影。

162
00:08:53,180 --> 00:08:56,560
现在不同的地方会产生
此数据以不同的方式。

163
00:08:56,560 --> 00:08:59,630
您可以直接调查你
用户，也可以只

164
00:08:59,630 --> 00:09:03,120
看看他们的选择，如果
你，例如Netflix的。

165
00:09:03,120 --> 00:09:05,640
没有他们看哪些电影？

166
00:09:05,640 --> 00:09:08,670
>> 我可能会质疑我的一些
这里的朋友，并找出

167
00:09:08,670 --> 00:09:12,910
杰森喜欢每一部电影
他看见了，也就不足为怪了那里。

168
00:09:12,910 --> 00:09:15,590
安迪只喜欢喽罗和阿姨人。

169
00:09:15,590 --> 00:09:19,330
莎拉喜欢内向外
复仇者，安迪的对立面。

170
00:09:19,330 --> 00:09:22,200
和SAM，以及，萨姆喜欢
所有的超级英雄电影，

171
00:09:22,200 --> 00:09:24,960
但没有的动画电影。

172
00:09:24,960 --> 00:09:30,630
>> 然后我可以查询一些新的
个人，其他一些用户喜欢自己

173
00:09:30,630 --> 00:09:34,520
并要求，好吧，如果我喜欢
这些电影之一，

174
00:09:34,520 --> 00:09:38,600
你可以做一个大概的预测
而其他的电影我可能会喜欢。

175
00:09:38,600 --> 00:09:41,890
也就是说，如果我喜欢里面
出，这是其它电影

176
00:09:41,890 --> 00:09:48,460
我可能也想看看
根据什么相似的人做？

177
00:09:48,460 --> 00:09:51,640
也就是说，我会去通过
我将筛选通过这个列表

178
00:09:51,640 --> 00:09:54,520
并找到刚才
个人谁也喜欢

179
00:09:54,520 --> 00:09:57,680
由内而外，谁符合我的喜好。

180
00:09:57,680 --> 00:10:00,824
嗯，这意味着，安迪和
山姆，他们不喜欢由内而外，

181
00:10:00,824 --> 00:10:02,240
所以我不会去考虑他们。

182
00:10:02,240 --> 00:10:06,130
我要摆脱自己的
数据进行这种比较。

183
00:10:06,130 --> 00:10:09,750
>> 那么我可以看看贾森
和萨拉思想和理货

184
00:10:09,750 --> 00:10:13,780
了其中，他们看到的电影
我没有，他们是否喜欢他们

185
00:10:13,780 --> 00:10:15,150
或不。

186
00:10:15,150 --> 00:10:17,820
我可以指望了，让我们说票。

187
00:10:17,820 --> 00:10:23,360
所以喽罗，例如可能有一个
选它，因为杰森喜欢它。

188
00:10:23,360 --> 00:10:27,170
这两个贾森和莎拉喜欢复仇者，
所以它有两票。

189
00:10:27,170 --> 00:10:30,700
而且，只有贾森喜欢蚂蚁人，
所以它会得到一票。

190
00:10:30,700 --> 00:10:34,870
所以，如果我不得不然后推荐
为自己而这些电影

191
00:10:34,870 --> 00:10:41,470
我可能是最容易看，我会
要选择ULTRON的年龄：复仇者。

192
00:10:41,470 --> 00:10:44,490
>> 因此，对于任何这些
系统，现在，我使用

193
00:10:44,490 --> 00:10:49,260
已生成不是关于数据
电影本身，而是偏好

194
00:10:49,260 --> 00:10:51,960
来自其他用户。

195
00:10:51,960 --> 00:10:54,150
这具有当然还有一些困难。

196
00:10:54,150 --> 00:10:55,920
如果你没有任何其他的用户？

197
00:10:55,920 --> 00:10:58,770
嗯，这就是所谓的启动问题。

198
00:10:58,770 --> 00:11:03,760
你必须有一些
之前的数据量你

199
00:11:03,760 --> 00:11:07,560
能够开始制作
这些建议。

200
00:11:07,560 --> 00:11:10,940
它的另一面是，一旦
你开始收集数据，

201
00:11:10,940 --> 00:11:13,870
如果你能收集更多
和越来越多的数据，

202
00:11:13,870 --> 00:11:17,850
你会越来越好
和更好的建议。

203
00:11:17,850 --> 00:11:21,650
>> 现在，我们可以翻译
此为代码。

204
00:11:21,650 --> 00:11:23,860
我们可以定义一个不同的
样的结构，

205
00:11:23,860 --> 00:11:25,720
在这种情况下，我们会打电话给它的用户。

206
00:11:25,720 --> 00:11:30,970
而且它有有关功能
这电影该用户的喜爱。

207
00:11:30,970 --> 00:11:34,560
难道他们想由内而外，
喽罗，复仇者，和蚂蚁人。

208
00:11:34,560 --> 00:11:36,660
然后，我们可以产生
一些伪跟随

209
00:11:36,660 --> 00:11:39,460
同样的过程，我之前使用。

210
00:11:39,460 --> 00:11:43,460
即，给定一个特定的
用户X，让我们推荐一个电影

211
00:11:43,460 --> 00:11:46,107
是X可能会喜欢。

212
00:11:46,107 --> 00:11:47,940
我们可以通过与
对于所有的电影，

213
00:11:47,940 --> 00:11:51,410
我们可以初始化一个分数
对于那部电影是0。

214
00:11:51,410 --> 00:11:54,080
然后我们就可以找到所有
其他用户的谁

215
00:11:54,080 --> 00:11:57,630
具有相同的首选项为x。

216
00:11:57,630 --> 00:11:59,990
然后，每
电影，他们喜欢，

217
00:11:59,990 --> 00:12:02,340
我们将增加那部电影的评分。

218
00:12:02,340 --> 00:12:05,010
无论电影中的
结束得分最高，

219
00:12:05,010 --> 00:12:07,600
那是一个我要建议。

220
00:12:07,600 --> 00:12:09,890
>> 这一切都不是真的不清楚。

221
00:12:09,890 --> 00:12:11,600
这一切都不是具有挑战性的。

222
00:12:11,600 --> 00:12:15,810
这些都是基本算法
你可以实现的今天。

223
00:12:15,810 --> 00:12:20,050
>> 现在有了真正的推荐系统，
你遇到了一些问题。

224
00:12:20,050 --> 00:12:23,300
如果有没有谁
精确匹配您的喜好？

225
00:12:23,300 --> 00:12:27,170
如果有用户谁
正是您的喜好，

226
00:12:27,170 --> 00:12:30,480
但随后大幅偏离
从你喜欢什么？

227
00:12:30,480 --> 00:12:36,210
我喜欢经典的哥斯拉
电影，但是我的妻子没有。

228
00:12:36,210 --> 00:12:39,430
我喜欢看他们，我
Netflix的帐户中包含他们。

229
00:12:39,430 --> 00:12:41,800
她的没有。

230
00:12:41,800 --> 00:12:45,230
当我们开始会发生什么
混合像这样的数据？

231
00:12:45,230 --> 00:12:47,690
这些都是挑战
你可以克服，

232
00:12:47,690 --> 00:12:51,900
他们只需要稍微
更复杂的算法。

233
00:12:51,900 --> 00:12:56,420
>> 现在在现实世界中，这
实际上操作，

234
00:12:56,420 --> 00:12:59,980
我们使用基于内容的过滤或
我们使用的协同过滤？

235
00:12:59,980 --> 00:13:01,910
答案是，我们使用其中的两者。

236
00:13:01,910 --> 00:13:06,350
几乎所有的主要用户
这种情况下，亚马逊，Facebook和Netflix公司，

237
00:13:06,350 --> 00:13:11,200
潘多拉，它们都使用相结合
这些不同的推荐系统。

238
00:13:11,200 --> 00:13:16,520
而当我们结合选择从
每次，我们称之为混合系统。

239
00:13:16,520 --> 00:13:20,750
它们以某种方式取决于
物体本身的特性，

240
00:13:20,750 --> 00:13:24,710
而且在某些方面，他们依靠
其他用户的喜好。

241
00:13:24,710 --> 00:13:28,120
这些混合系统，
他们是大企业，

242
00:13:28,120 --> 00:13:30,830
而且他们什么是当前的今天。

243
00:13:30,830 --> 00:13:32,839
>> 所以，非常感谢您来到我身边。

244
00:13:32,839 --> 00:13:35,380
我希望你已经得到了一点点
的理解有点什么

245
00:13:35,380 --> 00:13:37,430
使得这些系统的工作。

246
00:13:37,430 --> 00:13:41,980
下一次你在线，请记住，
不仅是你影响你的选择，

247
00:13:41,980 --> 00:13:44,680
但可能其他人的为好。

248
00:13:44,680 --> 00:13:46,480
再次感谢。

249
00:13:46,480 --> 00:13:47,186