个性化召回算法实践(一)——CF算法

协同过滤推荐（Collaborative Filtering Recommendation）主要包括基于用户的协同过滤算法与基于物品的协同过滤算法。
下面，以movielens数据集为例，分别实践这两种算法。

movielens数据集包含四列，【用户ID|电影ID|打分|时间戳】，根据用户的历史评分向用户召回电影候选集。

UserCF

基于用户的协同过滤算法主要包括两个步骤。

(1) 找到和目标用户兴趣相似的用户集合。

(2) 找到这个集合中的用户喜欢的，且目标用户没有听说过的物品推荐给目标用户
步骤(1)的关键就是计算两个用户的兴趣相似度。可以通过Jaccard(杰卡德)公式或者通过余弦相似度计算。代码中主要使用了余弦相似度：
\[ W(u,v) = \frac{N(u) \bigcap N(v)} {\sqrt{|N(u)| |N(v)|}} \]
主函数为recommend(self,userID,K,N,useIIF):

def recommend(self,userID,K,N,useIIF):
    W, user_item = self._UserSimilarity(self.X, self.y, useIIF)
    rank = {}
    interacted_items = user_item[userID]
    for v, wuv in sorted(W[userID].items(), reverse=True)[:K]:
        for i in user_item[v]:
            if i not in interacted_items:
                rank.setdefault(i, 0)
                rank[i] += wuv
    return sorted(rank.items(), key=lambda d: d[1], reverse=True)[:N]

其中，userID是将要为其推荐的用户ID，\(K\)代表要考虑多少个相似用户，\(N\)代表输出多少个推荐item。
函数_UserSimilarity用于计算用户之间的相似度，通过用户物品表与物品用户表计算出两个用户观看的相同的电影数量，当设定useIIF=True时，相同的电影数量变为加\(1 / math.log(1 + len(users))\)，原因是惩罚用户\(u\)和用户\(v\)共同兴趣列表中的热门物品。
然后，会挑选出\(K\)名最相似的用户，选出这些用户下的\(N\)部电影作为推荐目标。这里涉及到两个排序，一个是用户的相似度排序，一个是item与用户的权重排序。注意，这里的电影的权重是由用户相似度累加决定的。
全部代码如下所示：

import math
import pandas as pd


class UserCF:
    def __init__(self,X,y):
        self.X,self.y = X,y

    def recommend(self,userID,K,N,useIIF):
        """
        Args:
            userID:user id
            k: K users closest to the user's interest
            N:the number of recommendable item
            userIIF:whether or not use userIIF
        Returns:
            top N recommendation
            rank:[(item_id1,interest1),(item_id2,interest2)...]
        """
        W, user_item = self._UserSimilarity(self.X, self.y, useIIF)
        rank = {}
        interacted_items = user_item[userID]
        for v, wuv in sorted(W[userID].items(), reverse=True)[:K]:
            for i in user_item[v]:
                if i not in interacted_items:
                    rank.setdefault(i, 0)
                    rank[i] += wuv
        return sorted(rank.items(), key=lambda d: d[1], reverse=True)[:N]

    def _UserSimilarity(self,X,Y,useIIF=False):
        """
        Args:
            X: user id list
            Y: item id list
            userIIF: whether or not use userIIF
        Returns:
            W : user's interest correlation
            user_item: a dict:{user_id1:[item1,item2,...],..user_idn:[]}
        """
        # 建立倒排表
        item_user=dict()
        for i in range(X.count()):
            user=X.iloc[i]
            item=Y.iloc[i]
            if item not in item_user:
                item_user[item]=set()
            item_user[item].add(user)

        user_item=dict()
        for i in range(Y.count()):
            user=X.iloc[i]
            item=Y.iloc[i]
            if user not in user_item:
                user_item[user]=set()
            user_item[user].add(item)

        C={}
        N={}
        # C:输出用户u与v共同的物品数目矩阵
        for i,users in item_user.items():
            for u in users:
                N.setdefault(u,0)
                N[u]+=1
                C.setdefault(u,{})
                for v in users:
                    if u==v:
                        continue
                    C[u].setdefault(v,0)
                    if not useIIF:
                        C[u][v]+=1
                    else:
                        C[u][v]+=1 / math.log(1 + len(users))# 惩罚用户u和用户v共同兴趣列表中热门物品
        W=C.copy()
        for u,related_users in C.items():
            for v,cuv in related_users.items():
                W[u][v]=cuv/math.sqrt(N[u]*N[v])
        return W,user_item



if __name__ == '__main__':
    moviesPath = '../data/ml-1m/movies.dat'
    ratingsPath = '../data/ml-1m/ratings.dat'
    usersPath = '../data/ml-1m/users.dat'

    ratingsDF = pd.read_csv(ratingsPath, index_col=None, sep='::', header=None,names=['user_id', 'movie_id', 'rating', 'timestamp'])
    X=ratingsDF['user_id'][:100000]
    Y=ratingsDF['movie_id'][:100000]
    rank = UserCF(X,Y).recommend(1,K=10,N=10,useIIF=True)# 输出对用户1推荐的 top10 item
    print('UserCF result',rank)

ItemCF

基于物品的协同过滤（item-based collaborative filtering）算法是目前业界应用最多的算法。基于物品的协同过滤算法主要分为两步。

(1) 计算物品之间的相似度。

(2) 根据物品的相似度和用户的历史行为给用户生成推荐列表
与UserCF类似，下面也使用了余弦相似度作用item相似度的衡量。另外，也对活跃用户做了一种软性的惩罚。
全部代码如下所示：

#-*-coding:utf-8-*-
"""
author:jamest
date:20190306
ItemCF function
"""
import math
import pandas as pd


class ItemCF:
    def __init__(self,X,y):
        self.X,self.y = X,y

    def recommend(self,userID,K,N,useIUF):
        """
        Args:
            userID:user id
            k: K items closest to the user's items
            N:the number of recommendable item
            useIUF:whether or not use useIUF
        Returns:
            top N recommendation
            rank:[(item_id1,interest1),(item_id2,interest2)...]
        """
        W, user_item = self._ItemSimilarity(self.X, self.y, useIUF)
        rank = {}
        interacted_items = user_item[userID]
        for i in interacted_items:
            for j, wij in sorted(W[i].items(), reverse=True)[0:K]:
                if j not in interacted_items:
                    rank.setdefault(j, 0)
                    rank[j] += wij
        return sorted(rank.items(), key=lambda d: d[1], reverse=True)[:N]

    def _ItemSimilarity(self,X,Y,useIUF=False):
        """
        Args:
            X: user id list
            Y: item id list
            useIUF: whether or not use useIUF
        Returns:
            W : item's correlation
            user_item: a dict:{user_id1:[item1,item2,...],..user_idn:[]}
        """
        # 建立倒排表
        user_item = dict()
        for i in range(Y.count()):
            user = X.iloc[i]
            item = Y.iloc[i]
            if user not in user_item:
                user_item[user] = set()
            user_item[user].add(item)

        C = {}
        N = {}
        for u, items in user_item.items():
            for i in items:
                N.setdefault(i, 0)
                N[i] += 1
                C.setdefault(i, {})
                for j in items:
                    if i == j:
                        continue
                    C[i].setdefault(j, 0)
                    if not useIUF:
                        C[i][j] += 1
                    else:
                        C[i][j] += 1 / math.log(1 + len(items))  # 对活跃用户做了一种软性的惩罚
        W = C.copy()
        for i, related_items in C.items():
            for j, cij in related_items.items():
                W[i][j] = cij / math.sqrt(N[i] * N[j])
        return W, user_item



if __name__ == '__main__':
    moviesPath = '../data/ml-1m/movies.dat'
    ratingsPath = '../data/ml-1m/ratings.dat'
    usersPath = '../data/ml-1m/users.dat'

    # usersDF = pd.read_csv(usersPath,index_col=None,sep='::',header=None,names=['user_id', 'gender', 'age', 'occupation', 'zip'])
    # moviesDF = pd.read_csv(moviesPath,index_col=None,sep='::',header=None,names=['movie_id', 'title', 'genres'])
    ratingsDF = pd.read_csv(ratingsPath, index_col=None, sep='::', header=None,names=['user_id', 'movie_id', 'rating', 'timestamp'])
    X=ratingsDF['user_id'][:10000]
    Y=ratingsDF['movie_id'][:10000]
    rank = ItemCF(X,Y).recommend(1,K=10,N=10,useIUF=True)#输出对用户1推荐的 top10 item
    print('ItemCF result',rank)

参考：
推荐系统概述（一）
Github