Mahout SlopOne

关于推荐引擎

        如今的互联网中，无论是电子商务还是社交网络，对数据挖掘的需求都越来越大了，而推荐引擎正是数据挖掘完美体现；通过分析用户历史行为，将他可能喜欢内容推送给他，能产生相当好的用户体验，这就是推荐引擎。

推荐算法Slope one的原理

        首先Slope one是一种基于项目的协同过滤算法（Item-based Recommendation），简单介绍这种算法（若理解有误，欢迎大家更正，I am just a beginner）：根据用户们对产品的喜好程度，来将产品分类；举个简单例子：比如有10个用户，其中有9个人即喜欢产品A，也喜欢产品B，但只有2个人喜欢产品C；于是可以推断产品A和产品B是属于同类的，而产品C可能跟它们不是一类。

        好了话不多讲，让我们看看Slope one吧！

        Slope one是通过用户们对每个产品的评分，来计算产品间的一个差值；这种计算是通过 ​​线性回归​​ f(x) =  ax + b得到的，其中a = 1，正如它的名字Slope one（斜率为一）；另外用户的评分，在Slope one中是必不可少的。这里举

例看看它的计算方式：下面是一张用户对书籍的评分表

	书 1	书 2	书 3
用户A	5	3	2
用户B	3	4	未评分
用户C	未评分	2	5

        

        书1是否适合推荐给用户C，需要通过Slope one 计算出一个值来判定：首先得到书1和书2之间的平均差值X = （（5-3）+（3-4））/ 2 = 0.5，然后通过用户C对书2的打分得到相应的推荐值 2+0.5 = 2.5 （推荐引擎会通过推荐值的高低来选择要推荐的物品），这里只是通过书2来计算用户C对书1的推荐值，实际的Slope one算法中若要得到用户C对书1的推荐值，会把用户C评分过的所有书按此方法依次对书1（为评分的书）算推荐值，然后取平均值得到，放到表中如下：

（（（5-3）+（3-4））/ 2 +2 + （5 - 2）/ 1 + 5 ）/ 2 = 5.25 

实际应用中你还可以设权值，这里就不深入了。

        以上是Slope one的原理，接下来看看它在Mahout中是如何设计与实现的。

Mahout中Slope one的设计思路以及代码实现

        先简单介绍下，Mahout是Apache的一个开源项目，由Lucene项目组和Hadoop项目组分离出来，它实现了推荐引擎中的大部分经典算法，有兴趣的朋友可以研究研究

        首先我们需要基础数据，即用户对产品的评分，这部分数据可以来自数据库也可以来自文件，Mahout中对此设计了一个简单的数据库表，SQL如下：

​​1​​

​​CREATE​​​​TABLE​​​​taste_preferences (​​

​​2​​

​​user_id​​​​BIGINT​​​​NOT​​ ​​NULL​​​​,​​

​​3​​

​​item_id​​​​BIGINT​​​​NOT​​ ​​NULL​​​​,​​

​​4​​

​​preference​​​​FLOAT​​​​NOT​​ ​​NULL​​​​,​​

​​5​​

​​PRIMARY​​​​KEY​​​​(user_id, item_id),​​

​​6​​

​​INDEX​​​​(user_id),​​

​​7​​

​​INDEX​​​​(item_id)​​

​​8​​

​​)​​

        其次，Mahout在启动时，会对这部分数据进行处理，算出每对产品间的平均评分差值，已Map<ItemId, Map<ItemId, Average>>的数据结构存放在内存中（当然这帮牛人没有用Java中Map的实现，自己写了一个叫FastByIDMap的类）。处理基础数据的计算代码如下：

 1. 首先获取所有评过分的用户id （7，而dataModel就是用于存放我上面提到的基础）

 2. 然后依次计算每个用户评分过的产品间的平均评分差值 （9，具体在processOneUser中实现）

​​01​​

​​private​​​​void​​​​buildAverageDiffs() ​​​​throws​​​​TasteException {​​

​​02​​

​​log.info(​​​​"Building average diffs..."​​​​);​​

​​03​​

​​try​​​​{​​

​​04​​

​​buildAverageDiffsLock.writeLock().lock();​​

​​05​​

​​averageDiffs.clear();​​

​​06​​

​​long​​​​averageCount = 0L;​​

​​07​​

​​LongPrimitiveIterator it = dataModel.getUserIDs();​​

​​08​​

​​while​​​​(it.hasNext()) {​​

​​09​​

​​averageCount = processOneUser(averageCount, it.nextLong());​​

​​10​​

​​}​​

​​11​​

​​12​​

​​pruneInconsequentialDiffs();​​

​​13​​

​​updateAllRecommendableItems();​​

​​14​​

​​15​​

​​}​​​​finally​​​​{​​

​​16​​

​​buildAverageDiffsLock.writeLock().unlock();​​

​​17​​

​​}​​

​​18​​

​​}​​

 3. 首先取出该用户所有评分过的项目和评分值（4）

 4. 依次计算这些项目间的平均评分差值（6 ~ 26），并存储在内存中。

​​01​​

​​private​​​​long​​​​processOneUser(​​​​long​​​​averageCount,​​​​long​​ ​​userID) ​​​​throws​​​​TasteException {​​

​​02​​

​​log.debug(​​​​"Processing prefs for user {}"​​​​, userID);​​

​​03​​

​​// Save off prefs for the life of this loop iteration​​

​​04​​

​​PreferenceArray userPreferences = dataModel.getPreferencesFromUser(userID);​​

​​05​​

​​int​​​​length = userPreferences.length();​​

​​06​​

​​for​​​​(​​​​int​​​​i = ​​​​0​​​​; i < length -​​​​1​​​​; i++) {​​

​​07​​

​​float​​​​prefAValue = userPreferences.getValue(i);​​

​​08​​

​​long​​​​itemIDA = userPreferences.getItemID(i);​​

​​09​​

​​FastByIDMap<RunningAverage> aMap = averageDiffs.get(itemIDA);​​

​​10​​

​​if​​​​(aMap ==​​​​null​​​​) {​​

​​11​​

​​aMap =​​​​new​​​​FastByIDMap<RunningAverage>();​​

​​12​​

​​averageDiffs.put(itemIDA, aMap);​​

​​13​​

​​}​​

​​14​​

​​for​​​​(​​​​int​​​​j = i + ​​​​1​​​​; j < length; j++) {​​

​​15​​

​​// This is a performance-critical block​​

​​16​​

​​long​​​​itemIDB = userPreferences.getItemID(j);​​

​​17​​

​​RunningAverage average = aMap.get(itemIDB);​​

​​18​​

​​if​​​​(average ==​​​​null​​ ​​&& averageCount < maxEntries) {​​

​​19​​

​​average = buildRunningAverage();​​

​​20​​

​​aMap.put(itemIDB, average);​​

​​21​​

​​averageCount++;​​

​​22​​

​​}​​

​​23​​

​​if​​​​(average !=​​​​null​​​​) {​​

​​24​​

​​average.addDatum(userPreferences.getValue(j) - prefAValue);​​

​​25​​

​​}​​

​​26​​

​​}​​

​​27​​

​​RunningAverage itemAverage = averageItemPref.get(itemIDA);​​

​​28​​

​​if​​​​(itemAverage ==​​​​null​​​​) {​​

​​29​​

​​itemAverage = buildRunningAverage();​​

​​30​​

​​averageItemPref.put(itemIDA, itemAverage);​​

​​31​​

​​}​​

​​32​​

​​itemAverage.addDatum(prefAValue);​​

​​33​​

​​}​​

​​34​​

​​return​​​​averageCount;​​

​​35​​

​​}​​

        以上是启动时做的事，而当某个用户来了，需要为他计算推荐列表时，就快速许多了（是一个空间换时间的思想），下面的方法是某一个用户对其某一个他未评分过的产品的推荐值，参数UserId：用户ID；ItemId：为评分的产品ID

 1. 再次取出该用户评分过的所有产品（4）：PreferenceArray prefs中保存着ItemID和该用户对它的评分

2. 取得上一步得到的prefs中的所有物品与itemID代表的物品之间的平均评分差值（5），其中DiffStoragediffStorage

对象中存放中每对产品间的平均评分差值（而上面启动时的计算都是在MySQLJDBCDiffStorage中实现的，计算后的

值也存于其中，它是DiffStorage接口的实现），所以取得的流程很简单，这里不贴代码了

3. 最后就是依次推算评分过的产品到未评分的产品的一个推荐值 = 平均评分差值（两者间的） + 已评分的分值（用

户对其中一个评分），然后将这些推荐值取个平均数（7 ~ 37），其中11行判断是否要考虑权重。

​​01​​

​​private​​​​float​​​​doEstimatePreference(​​​​long​​​​userID,​​​​long​​ ​​itemID) ​​​​throws​​​​TasteException {​​

​​02​​

​​double​​​​count =​​​​0.0​​​​;​​

​​03​​

​​double​​​​totalPreference =​​​​0.0​​​​;​​

​​04​​

​​PreferenceArray prefs = getDataModel().getPreferencesFromUser(userID);​​

​​05​​

​​RunningAverage[] averages = diffStorage.getDiffs(userID, itemID, prefs);​​

​​06​​

​​int​​​​size = prefs.length();​​

​​07​​

​​for​​​​(​​​​int​​​​i = ​​​​0​​​​; i < size; i++) {​​

​​08​​

​​RunningAverage averageDiff = averages[i];​​

​​09​​

​​if​​​​(averageDiff !=​​​​null​​​​) {​​

​​10​​

​​double​​​​averageDiffValue = averageDiff.getAverage();​​

​​11​​

​​if​​​​(weighted) {​​

​​12​​

​​double​​​​weight = averageDiff.getCount();​​

​​13​​

​​if​​​​(stdDevWeighted) {​​

​​14​​

​​double​​​​stdev = ((RunningAverageAndStdDev) averageDiff).getStandardDeviation();​​

​​15​​

​​if​​​​(!Double.isNaN(stdev)) {​​

​​16​​

​​weight /=​​​​1.0​​​​+ stdev;​​

​​17​​

​​}​​

​​18​​

​​// If stdev is NaN, then it is because count is 1. Because we're weighting by count,​​

​​19​​

​​// the weight is already relatively low. We effectively assume stdev is 0.0 here and​​

​​20​​

​​// that is reasonable enough. Otherwise, dividing by NaN would yield a weight of NaN​​

​​21​​

​​// and disqualify this pref entirely​​

​​22​​

​​// (Thanks Daemmon)​​

​​23​​

​​}​​

​​24​​

​​totalPreference += weight * (prefs.getValue(i) + averageDiffValue);​​

​​25​​

​​count += weight;​​

​​26​​

​​}​​​​else​​​​{​​

​​27​​

​​totalPreference += prefs.getValue(i) + averageDiffValue;​​

​​28​​

​​count +=​​​​1.0​​​​;​​

​​29​​

​​}​​

​​30​​

​​}​​

​​31​​

​​}​​

​​32​​

​​if​​​​(count <=​​​​0.0​​​​) {​​

​​33​​

​​RunningAverage itemAverage = diffStorage.getAverageItemPref(itemID);​​

​​34​​

​​return​​​​itemAverage ==​​​​null​​ ​​? Float.NaN : (​​​​float​​​​) itemAverage.getAverage();​​

​​35​​

​​}​​​​else​​​​{​​

​​36​​

​​return​​​​(​​​​float​​​​) (totalPreference / count);​​

​​37​​

​​}​​

​​38​​

​​}​​

         Slope one 的源码已分析完毕。

        其实Slope one推荐算法很流行，被很多网站使用，包括一些大型网站；我个人认为最主要的原因是它具备如下优势：

        1. 实现简单并且易于维护。

        2. 响应即时（只要用户做出一次评分，它就能有效推荐，根据上面代码很容易理解），并且用户的新增评分对推荐数据的改变量较小，应为在内存中存储的是物品间的平均差值，新增的差值只需累加一下，切范围是用户评分过的产品。

        3. 由于是基于项目的协同过滤算法，适用于当下火热的电子商务网站，原因电子商务网站用户量在几十万到上百万，产品量相对于之则要小得多，所以对产品归类从性能上讲很高效。

        分析至此，祝大家周末愉快。

参考资料：

1. Slope one ​​http://zh.wikipedia.org/wiki/Slope_one​​

2. 探索推荐引擎内部的秘密，第 2 部分: 深入推荐引擎相关算法 - 协同过滤 

    ​​http://www.ibm.com/developerworks/cn/web/1103_zhaoct_recommstudy2/index.html​​