python实现itemCF and userCF

http://my.oschina.net/zhangjiawen/blog/185625

１基于用户的协同过滤算法：

基于用户的协同过滤算法是推荐系统中最古老的的算法，可以说是这个算法的诞生标志了推荐系统的诞生。该算法在1992年被提出，并应用于邮件过滤系统，1994年被GroupLens用于新闻过滤。

在一个在线个性化推荐系统中，当一个用户A需要个性化推荐时，可以先找到和他有相似兴趣的其他用户，然后把那些用户喜欢的而用户A没有接触过的物品推荐给A。这种方法称为基于用户的协同过滤算法。

给定用户u和用户v，令N(u)表示用户u曾经有过正反馈的物品集合，通过余弦相似度计算用户的相似度。由于很多用户相互之间并没有对同样的物品产生过行为，即，因此可以先计算的用户对(u,v)。为此，可以首先建立物品到用户的倒查表，对于每个物品保存对该物品产生过行为的用户列表。令稀疏矩阵，假设用户u和用户v同时属于倒查表中K个物品对应的用户列表，就有（即用户u和v对相同物品产生正反馈的物品数），从而可以扫描倒查表中每个物品对应的用户列表，将用户列表中的两两用户对应的加1，最终就可以获得所有用户之间不为0的（也就是余弦相似度的分子）。

得到用户之间的兴趣相似度之后，基于用户的协同过滤算法（User Based Collaborative Filering）会给用户推荐和他兴趣最相似的K个用户喜欢的物品。如下公式度量了UserCF算法中用户u对物品i的感兴趣程度：

其中，S(u,k)包含和用户u兴趣相似度最接近的k个用户集合，N(i)是对物品i有过行为的用户集合，是用户u和用户v的兴趣相似度，代表用户v对物品i的兴趣，因为使用的是单一行为的隐反馈数据，因此为1。

根据以上思路，使用Python实现UserCF算法的代码如下：

import random

002
import math

003
class UserBasedCF:

004
    def __init__(self,datafile = None):

005
        self.datafile = datafile

006
        self.readData()

007
        self.splitData(3,47)

008
         
009
    def readData(self,datafile = None):

010
    """

011
    read the data from the data file which is a data set

012
    """

013
        self.datafile = datafile or self.datafile

014
        self.data = []

015
    for line in open(self.datafile):

016
        userid,itemid,record,_ = line.split()

017
        self.data.append((userid,itemid,int(record)))

018
 
019
    def splitData(self,k,seed,data=None,M = 8):

020
        """

021
        split the data set

022
        testdata is a test data set

023
        traindata is a train set 

024
        test data set / train data set is 1:M-1

025
        """

026
        self.testdata = {}

027
        self.traindata = {}

028
        data = data or self.data

029
        random.seed(seed)

030
        for user,item, record in self.data:

031
            if random.randint(0,M) == k:

032
                self.testdata.setdefault(user,{})

033
                self.testdata[user][item] = record

034
            else:

035
                self.traindata.setdefault(user,{})

036
                self.traindata[user][item] = record

037
     
038
    def userSimilarityBest(self,train = None):

039
    """

040
    the other method of getting user similarity which is better than above

041
    you can get the method on page 46

042
    In this experiment，we use this method

043
    """

044
        train = train or self.traindata

045
        self.userSimBest = dict()

046
        item_users = dict()

047
        for u,item in train.items():

048
            for i in item.keys():

049
                item_users.setdefault(i,set())

050
                item_users[i].add(u)

051
        user_item_count = dict()

052
        count = dict()

053
        for item,users in item_users.items():

054
            for u in users:

055
                user_item_count.setdefault(u,0)

056
                user_item_count[u] += 1

057
        for v in users:

058
            if u == v:continue

059
        count.setdefault(u,{})

060
        count[u].setdefault(v,0)

061
        count[u][v] += 1

062
        for u ,related_users in count.items():

063
            self.userSimBest.setdefault(u,dict())

064
            for v, cuv in related_users.items():

065
                self.userSimBest[u][v] = cuv / math.sqrt(user_item_count[u] * user_item_count[v] * 1.0)

066
     
067
    def recommend(self,user,train = None,k = 8,nitem = 40):

068
        train = train or self.traindata

069
        rank = dict()

070
        interacted_items = train.get(user,{})

071
        for v ,wuv in sorted(self.userSimBest[user].items(),key = lambda x : x[1],reverse = True)[0:k]:

072
            for i , rvi in train[v].items():

073
                if i in interacted_items:

074
                    continue

075
                rank.setdefault(i,0)

076
                rank[i] += wuv

077
            return dict(sorted(rank.items(),key = lambda x :x[1],reverse = True)[0:nitem])

078
 
079
    def recallAndPrecision(self,train = None,test = None,k = 8,nitem = 10):

080
    """

081
    Get the recall and precision, the method you want to know is listed 

082
    in the page 43

083
    """

084
    train = train or self.traindata

085
    test = test or self.testdata

086
    hit = 0

087
    recall = 0

088
    precision = 0

089
    for user in train.keys():

090
        tu = test.get(user,{})

091
    rank = self.recommend(user, train = train,k = k,nitem = nitem)

092
    for item,_ in rank.items():

093
        if item in tu:

094
            hit += 1

095
    recall += len(tu)

096
    precision += nitem

097
    return (hit / (recall * 1.0),hit / (precision * 1.0))

098
     
099
    def coverage(self,train = None,test = None,k = 8,nitem = 10):

100
        train = train or self.traindata

101
        test = test or self.testdata

102
        recommend_items = set()

103
        all_items = set()

104
        for user in train.keys():

105
            for item in train[user].keys():

106
                all_items.add(item)

107
        rank = self.recommend(user, train, k = k, nitem = nitem)

108
        for item,_ in rank.items():

109
            recommend_items.add(item)

110
        return len(recommend_items) / (len(all_items) * 1.0)

111
     
112
    def popularity(self,train = None,test = None,k = 8,nitem = 10):

113
    """

114
    Get the popularity

115
    the algorithm on page 44

116
    """

117
        train = train or self.traindata

118
        test = test or self.testdata

119
        item_popularity = dict()

120
        for user ,items in train.items():

121
            for item in items.keys():

122
                item_popularity.setdefault(item,0)

123
                item_popularity[item] += 1

124
        ret = 0

125
        n = 0

126
        for user in train.keys():

127
            rank = self.recommend(user, train, k = k, nitem = nitem)

128
        for item ,_ in rank.items():

129
            ret += math.log(1+item_popularity[item])

130
        n += 1

131
        return ret / (n * 1.0)

132
 
133
    def testUserBasedCF():

134
        cf = UserBasedCF('u.data')

135
        cf.userSimilarityBest()

136
        print "%3s%20s%20s%20s%20s" % ('K',"recall",'precision','coverage','popularity')

137
        for k in [5,10,20,40,80,160]:

138
            recall,precision = cf.recallAndPrecision( k = k)

139
            coverage = cf.coverage(k = k)

140
            popularity = cf.popularity(k = k)

141
            print "%3d%19.3f%%%19.3f%%%19.3f%%%20.3f" % (k,recall * 100,precision * 100,coverage * 100,popularity)

142
 
143
if __name__ == "__main__":

144
testUserBasedCF()

2 基于物品的协同过滤算法：

基于物品的协同过滤算法（Item-Based Collaborative Filtering）是目前业界应用最多的算法，亚马逊、Netflix、Hulu、YouTube都采用该算法作为其基础推荐算法。

基于用户的协同过滤算法有一些缺点：随着网站的用户数目越来越大，计算用户兴趣相似度矩阵将越来越困难，其运算时间复杂度和空间复杂度的增长和用户数的增长近似平方关心。并且，基于用户的协同过滤算法很难对推荐结果做出解释。因此亚马逊提出了基于物品的协同过滤算法。

基于物品的协同过滤算法给用户推荐那些和他们之前喜欢的物品相似的物品。不过ItemCF算法并不利用物品的内容属性计算物品之间的相似度，它主要通过分析用户的行为记录计算用户之间的相似度，也就是说物品A和物品B具有很大的相似度是因为喜欢物品A的用户大都也喜欢物品B（这一点也是基于物品的协同过滤算法和基于内容的推荐算法最主要的区别）。同时，基于物品的协同过滤算法可以利用用户的历史行为给推荐结果提供推荐解释，用于解释的物品都是用户之前喜欢的或者购买的物品。

“Customers Who Bought This Item Also Bought”（亚马逊显示相关物品推荐时的标题），从这句话的定义出发，利用以下公式定义物品之间的相似度：

其中N(i)是喜欢物品i的用户数，分子是同时喜欢物品i和物品j的用户数。这个公式惩罚了物品j的权重，减轻了热门物品会和很多物品相似的可能性（这样wij的值会很大，接近于1）。这个公式说明两个物品产生相似度是因为它们共同被很多用户喜欢，也就是说每个用户都可以通过他们的历史兴趣列表给物品“贡献”相似度。

和UserCF算法类似，用ItemCF算法计算物品相似度时也可以首先建立用户-物品倒排表，即对每个用户建立一个包含他喜欢的物品的列表，然后对于每个用户，将他物品列表中的物品两两在共现矩阵C中加1，最终就可以得到所有物品之间不为0的，也就是公式中的分子。

在得到物品之间的相似度后，ItemCF通过如下公式计算用户u对一个物品i的兴趣：

其中，N(u)是用户喜欢的物品集合，S(i,k)是和物品i最相似的k个物品的集合，是物品j和物品i的相似度，是用户u对物品i的兴趣，对于隐反馈数据集，如果用户u对物品i有过行为，即可令为1。

根据以上思路，使用Python实现ItemCF算法的代码如下：

001
import math

002
import random

003
class ItemBasedCF:

004
    def __init__(self, datafile = None):

005
        self.datafile = datafile

006
        self.readData()

007
        self.splitData(3,47)

008
         
009
    def readData(self,datafile = None):

010
        self.datafile = datafile or self.datafile

011
        self.data = []

012
        file = open(self.datafile,'r')

013
        for line in file.readlines()[0:100*1000]:

014
            userid, itemid, record,_ = line.split()

015
            self.data.append((userid,itemid,int(record)))

016
             
017
    def splitData(self,k,seed,data=None,M = 8):

018
        self.testdata = {}

019
        self.traindata = {}

020
        data = data or self.data

021
        random.seed(seed)

022
        for user,item,record in self.data:

023
            if random.randint(0,7) == k:

024
                self.testdata.setdefault(item,{})

025
                self.testdata[item][user] = record

026
            else:

027
                self.traindata.setdefault(item,{})

028
                self.traindata[item][user] = record

029
                 
030
def ItemSimilarity(self, train = None):

031
    train = train or self.traindata

032
    self.itemSim = dict()

033
    #user_items = dict()

034
    item_user_count = dict() #item_user_count{item: likeCount} the number of users who like the item

035
    count = dict() #count{i:{j:value}} the number of users who both like item i and j

036
    for user, item in train.items(): #initialize the user_items{user: items}

037
        for i in item.keys():

038
            item_user_count.setdefault(i,0)

039
            item_user_count[i] += 1

040
            for j in item.keys():

041
                if i == j:

042
                    continue

043
        count.setdefault(i,{})

044
        count[i].setdefault(j,0)

045
        count[i][j] += 1

046
     for i, related_items in count.items():

047
        self.itemSim.setdefault(i,dict())

048
        for j, cuv in related_items.items():

049
            self.itemSim[i].setdefault(j,0)

050
            self.itemSim[i][j] = cuv / math.sqrt(item_user_count[i] * item_user_count[j] * 1.0)

051
             
052
def recommend(self,user,train = None, k = 8, nitem = 40):

053
    train = train or self.traindata

054
    rank = dict()

055
    ru = train.get(user,{})

056
    for i,pi in ru.items():

057
        for j,wj in sorted(self.itemSim[i].items(), key = lambda x:x[1], reverse = True)[0:k]:

058
            if j in ru:

059
                continue

060
        rank.setdefault(j,0)

061
        rank[j] += wj

062
    #print dict(sorted(rank.items(), key = lambda x:x[1], reverse = True)[0:nitem])

063
    return dict(sorted(rank.items(), key = lambda x:x[1], reverse = True)[0:nitem])

064
     
065
    def recallAndPrecision(self,train = None,test = None,k = 8,nitem = 10):

066
    train = train or self.traindata

067
    test = test or self.testdata

068
    hit = 0

069
    recall = 0

070
    precision = 0

071
    for user in train.keys():

072
        tu = test.get(user,{})

073
    rank = self.recommend(user,train = train,k = k,nitem = nitem)

074
    for item,_ in rank.items():

075
        if item in tu:

076
            hit += 1

077
            recall += len(tu)

078
            precision += nitem

079
    return (hit / (recall * 1.0),hit / (precision * 1.0))

080
     
081
    def coverage(self,train = None,test = None,k = 8,nitem = 10):

082
        train = train or self.traindata

083
        test = test or self.testdata

084
        recommend_items = set()

085
        all_items = set()

086
        for user in train.keys():

087
            for item in train[user].keys():

088
                all_items.add(item)

089
        rank = self.recommend(user, train, k = k, nitem = nitem)

090
        for item,_ in rank.items():

091
            recommend_items.add(item)

092
        return len(recommend_items) / (len(all_items) * 1.0)

093
     
094
    def popularity(self,train = None,test = None,k = 8,nitem = 10):

095
    """

096
    Get the popularity

097
    the algorithm on page 44

098
    """

099
        train = train or self.traindata

100
        test = test or self.testdata

101
        item_popularity = dict()

102
        for user ,items in train.items():

103
            for item in items.keys():

104
                item_popularity.setdefault(item,0)

105
                item_popularity[item] += 1

106
        ret = 0

107
        n = 0

108
        for user in train.keys():

109
            rank = self.recommend(user, train, k = k, nitem = nitem)

110
        for item ,_ in rank.items():

111
            ret += math.log(1+item_popularity[item])

112
        n += 1

113
        return ret / (n * 1.0)

114
         
115
    def testRecommend():

116
        ubcf = ItemBasedCF('u.data')

117
        ubcf.readData()

118
        ubcf.splitData(4,100)

119
        ubcf.ItemSimilarity()

120
        user = "345"

121
        rank = ubcf.recommend(user,k = 3)

122
        for i,rvi in rank.items():

123
            items = ubcf.testdata.get(user,{})

124
            record = items.get(i,0)

125
            print "%5s: %.4f--%.4f" %(i,rvi,record)

126
             
127
    def testItemBasedCF():

128
        cf = ItemBasedCF('u.data')

129
        cf.ItemSimilarity()

130
        print "%3s%20s%20s%20s%20s" % ('K',"recall",'precision','coverage','popularity')

131
        for k in [5,10,20,40,80,160]:

132
            recall,precision = cf.recallAndPrecision( k = k)

133
        coverage = cf.coverage(k = k)

134
        popularity = cf.popularity(k = k)

135
        print "%3d%19.3f%%%19.3f%%%19.3f%%%20.3f" % (k,recall * 100,precision * 100,coverage * 100,popularity)

136
         
137
if __name__ == "__main__":

138
testItemBasedCF()

3 UserCF和ItemCF的综合比较：

UserCF给用户推荐那些和他有共同兴趣爱好的用户喜欢的物品，而ItemCF给用户推荐那些和他之前喜欢的物品类似的物品。从这个原理可以看到，UserCF的推荐结果着重于反映和用户兴趣相似的小群体的热点，而ItemCF的推荐结果着重于维系用户的历史兴趣。UserCF的推荐更社会化，反映了用户所在的小型兴趣群体中物品的热门程度，而ItemCF的推荐更加个性化，反映了用户自己的兴趣传承。同时，从技术上来说，UserCF需要维护一个用户相似度的矩阵，而ItemCF需要维护一个物品相似度矩阵。从存储的角度来说，如果用户很多，那么维护用户兴趣相似度矩阵需要很大的空间，同理，如果物品很多，维护物品相似度矩阵代价较大。

对于UserCF和ItemCF，我们采用http://www.grouplens.org/node/73 的数据集进行测试，使用准确率/召回率、覆盖率和流行度对实验结果进行评测。

对用户u推荐N个物品R(u)，令用户u在测试集上喜欢的物品集合为T(u)，则：