Programming Collective Intelligence 推荐系统 读书笔记二

  这章主要讲了如何做推荐，现在推荐最常用的几种算法：Collaborative Filtering、Cluster Models、Search-Based Methods、Item-to-Item Collaborative Filtering.前两种是通过找相似的Customer,后两种通过找相似的Item.论文Amazon.com Recommendations Item-to-Item Collaborative Filtering 对这几种算法都有介绍。这章主要提了Collaborative Filtering和tem-to-Item Collaborative Filtering。 Collaborative Filtering：通过搜索大量的Customer数据集来找到那一小撮和你口味相似的。书中举了一个电影评论的例子，每个人都对一些电影进行评等级，通过这些数据来找到和你口味相似的人，以及对你没有看过的电影做推荐，并以这个例子演示了如何做推荐。

准备数据：（本笔记的代码使用ruby实现，python代码的实现见原书）

critics={
    'Lisa Rose' => {'Lady in the Water' => 2.5, 'Snakes on a Plane' => 3.5,
    'Just My Luck' => 3.0, 'Superman Returns' => 3.5, 'You, Me and Dupree' => 2.5,
    'The Night Listener' => 3.0},

    'Gene Seymour' => {'Lady in the Water' => 3.0, 'Snakes on a Plane' => 3.5,
    'Just My Luck' => 1.5, 'Superman Returns' => 5.0, 'The Night Listener'=> 3.0,
    'You, Me and Dupree' => 3.5},

    'Michael Phillips' => {'Lady in the Water' => 2.5, 'Snakes on a Plane' => 3.0,
    'Superman Returns' => 3.5, 'The Night Listener' => 4.0},

    'Claudia Puig' => {'Snakes on a Plane' => 3.5, 'Just My Luck' => 3.0,
    'The Night Listener' => 4.5, 'Superman Returns' => 4.0,
    'You, Me and Dupree' => 2.5},

    'Mick LaSalle'=> {'Lady in the Water' => 3.0, 'Snakes on a Plane' => 4.0,
    'Just My Luck' => 2.0, 'Superman Returns' => 3.0, 'The Night Listener' => 3.0,
    'You, Me and Dupree' => 2.0},

    'Jack Matthews'=> {'Lady in the Water' => 3.0, 'Snakes on a Plane' => 4.0,
    'The Night Listener'=> 3.0, 'Superman Returns'=> 5.0, 'You, Me and Dupree' => 3.5},

    'Toby' => {'Snakes on a Plane' =>4.5,'You, Me and Dupree' =>1.0,'Superman Returns' => 4.0}
}

 

定义相似度:

欧拉距离：

 

 

 

代码实现：

 

def sim_distance(prefs,person1,person2)
    si = {}
    prefs[person1].each_key do |item|
        si[item] = 1 if prefs[person2][item]
    end

    return 0 if si.empty?

    sum_of_squares = si.keys.inject(0) do |sum,item|
        sum + (prefs[person1][item] - prefs[person2][item]) ** 2
    end

    return 1 / (1 + sum_of_squares)
end

 

 

 Pearson Correlation Score：

 

代码实现：

 

def sim_pearson(prefs,person1,person2)
    si = {}
    prefs[person1].each_key do |item|
        si[item] = 1 if prefs[person2][item]
    end

    return 0 if si.empty?

    sum1 = si.keys.inject(0){|sum,item| sum + prefs[person1][item]}
    sum2 = si.keys.inject(0){|sum,item| sum + prefs[person2][item]}

    sum1Sq = si.keys.inject(0){|sum,item| sum + prefs[person1][item] ** 2}
    sum2Sq = si.keys.inject(0){|sum,item| sum + prefs[person2][item] ** 2}

    pSum = si.keys.inject(0){|sum,item| sum + prefs[person1][item] * prefs[person2][item]}
    num = pSum - (sum1 * sum2 / si.size)
    den = Math.sqrt((sum1Sq - sum1 ** 2 / si.size) * (sum2Sq - sum2 ** 2 / si.size))
    return (if den == 0 then 0 else num/den end)
end

 根据前面的两个相似度的函数，我们可以计算和你相同电影的口味的top N了： 

def top_matches(prefs,person,n=5,similarity="sim_pearson")
    scores = []
    #计算相似度
    prefs.each_key{|other|  scores << eval("[#{similarity}(prefs,person,other),other]")  if other != person}
    #返回相似读最高的人
    return scores.sort.reverse[0...n]
end

下面我们看看如何推荐你没有看过的电影，我们平时的想法是，如果这部电影 
大家评论很好，我们就认为值得我们看，但是你的口味可能和这些评论很高的 
的人不同，所以和你口味相似的人评论很高的电影，推荐给你效果会很好。 
我们这样虽然一个人对一部电影的评价很高，但是由于他和你的口味不同，那么 
这个评价对于你的贡献也不会太多。结合相似度和评价的一种方法是： 
相似度与评价的成绩作为这个电影评论的一个贡献，同时为了避免评论的人越多 
最终的总分越高，可以用这个公式： 
所有人（相似度与评论分的成绩） 之和 / 相似度之和，于是我们可以得到如下 
代码： 

def get_recommendations(prefs,person,similarity='sim_pearson')
    totals = {}
    simSums = {}
    prefs.each_key do |other|
        #跳过自己
        next if person == other
        sim = eval("#{similarity}(prefs,person,other)")
        #去掉similarity为0的人
        next if sim <= 0

        prefs[other].each_key do |item|
            if (not prefs[person][item]) or (prefs[person][item] == 0) then
                #计算相似度和评论的成绩之和
                totals[item] = if totals[item] then
                                  totals[item] + prefs[other][item] * sim
                                else
                                  prefs[other][item] * sim
                                end
                #相似度之和
                simSums[item] = if simSums[item] then
                                    simSums[item] + sim
                                else
                                    sim
                                end
            end
        end
    end
    #计算每个电影的符合你口味的程度
    rankings = totals.map{|item,total| [total/simSums[item],item]}
    return rankings.sort.reverse
end

如何根据用户的评论来看产品的相似度呢？一种方法是通过看一个人喜欢某个产品，再看看他喜欢 
的其他产品，这其实和前面的方法一样，你只需要把people和items交换一下位置。这样我们只需要 
对前面的字典做一下转置操作即可： 

def transform_prefs(prefs)
    result = {}
    prefs.each_key do |person|
        prefs[person].each_key do |item|
            result[item] = {} if not result[item]
            result[item][person] = prefs[person][item]
        end
    end
    result
end

然后我们就可以向前面的代码一样做top match和recommendation了： 

movies = transform_prefs(critics)
p top_matches(movies,'Superman Returns')
p get_recommendations(movies,'Just My Luck')

二、Item-Based Filtering: 
前面介绍的算法被称为user-based collaborative filtering，每次都要计算一下 
Customer之间的相似度，伸缩性不够好，一种更好的方法是事先把Item之间相似度 
计算出来，然后排序好，保存下来，用户每次请求的时候只需要直接把top N返回给 
用户就可以了，这个算法是基于 Items之间的相似性比较与Users之间的比较变化要 
少这个事实的。 
根据这个思想，我们可以事先把Items之间的相似性计算出来并保存下来，下面就是 
算法的实现: 

def calculate_similar_items(prefs,n=10)
    result = {}
    #把矩阵转置成item-centric的
    item_prefs = transform_prefs(prefs)
    c = 0
    item_prefs.each_key do |item|
        c += 1
        printf("[%d / %d]",c,item_prefs.size) if c % 100 == 0
        #把与item top n相似的记录下来，并保存在result map中
        scores = top_matches(item_prefs,item,n,'sim_distance')
        result[item] = scores
    end
    return result
end

现在你可以直接使用我们前面已经保存下来的Item之间的相似度来做推荐了： 

def get_recommended_items(prefs,item_match,user)
    user_ratings = prefs[user]
    scores = {}
    total_sim = {}

    user_ratings.each do |item,rating|
        #已经计算出来的top n item
        item_match[item].each do |similarity,item2|
            #跳过已经rated的item
            next if user_ratings[item2]
            #所有rating的 相似度*rating 之和
            scores[item2] = if scores[item2] then
                                scores[item2] + similarity * rating
                            else
                                similarity * rating
                            end
            #所有的相似度之和
            total_sim[item2] = if total_sim[item2] then
                                total_sim[item2] + similarity
                              else
                                similarity
                              end
        end
        rankings = scores.map{|item,score| [score/total_sim[item],item]}
        return rankings.sort.reverse
    end
end
item_sim = calculate_similar_items(critics)
p get_recommended_items(critics,item_sim,'Toby')