推荐系统：从协同过滤的起源

Item	Rel(i)
Item A	1
Item B	3
Item C	2

Item	Rel(i)	Position (i)	Contribution to DCG
Item A	1	1	1
Item B	3	2	$\frac{3}{\log_2(3)} \approx 1.893$
Item C	2	3	$\frac{2}{\log_2(4)}=1$

基于用户的协同过滤

基于用户的协同过滤简称UserCF，核心是推荐与用户相似的用户喜欢的物品。简单来说，$n$个用户对$m$个物体的打分会成为一个$n*m$的User-Item矩阵。每个用户都是一个$m$维向量，这样就可以通过计算相似度来计算不同用户之间的相似度。最终能够得到一个下三角矩阵，其中包含了每个用户两两之间的相似度。使用较多的是余弦相似度。

在实际环境中，用户/物品评分矩阵是一个稀疏矩阵。

UserCF的核心是计算用户相似度，完整代码如下：

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

class UserBasedCF:
    def __init__(self, ratings, k=2):
        """
		初始化UserCF模型
		
		入参：
		ratings：二维评分矩阵
		k：最近邻用户数
        """
        self.ratings = ratings
        self.k = k
        self.user_similarity = self.calculate_user_similarity()

    def calculate_user_similarity(self):
        """
        计算用户相似度
        
        返回：
        用户相似度的二维数组
        """
        return cosine_similarity(self.ratings)

    def predict_rating(self, user_index, item_index):
        """
        为特定用户计算特定物体的打分

		入参：
		user_index：用户的索引
		item_index：物品的索引
        
		返回：
		预测得分
        """
        # 首先根据用户相似度得到最相似的k个用户，并去除自身
        similar_users = np.argsort(self.user_similarity[user_index])[-self.k:]
        similar_users = similar_users[similar_users != user_index]
        
        numerator = 0
        denominator = 0
        
        # 找到相似用户
        for neighbor in similar_users:
            if self.ratings[neighbor, item_index] > 0:
                # 分子是相似用户对物品的评分*相似度
                numerator += self.user_similarity[user_index, neighbor] * self.ratings[neighbor, item_index]
                # 分母是用户相似度之和
                denominator += abs(self.user_similarity[user_index, neighbor])
        
        if denominator == 0:
            return 0
        else:
            # 返回分子/分母
            return numerator / denominator

    def recommend(self, user_index, num_recommendations=5):
        """
        为用户推荐具体物品
        
        入参：
        user_index：用户索引
        num_recommendations：推荐物品个数
		
	    返回：
        推荐物品的索引列表
        """
        user_ratings = self.ratings[user_index]
        print(f'用户{user_index}的评分：{user_ratings}')
        item_indices = np.where(user_ratings == 0)[0]
        print(f'用户{user_index}未评分的物品：{item_indices}')
        
        predictions = np.array([self.predict_rating(user_index, item) for item in item_indices])
        recommended_items = item_indices[np.argsort(predictions)[-num_recommendations:]]
        
        return recommended_items
        
        predictions = np.array([self.predict_rating(user_index, item) for item in item_indices])
        recommended_items = item_indices[np.argsort(predictions)[-num_recommendations:]]
        
        return recommended_items

现在，我们有一个用户-物品评分矩阵，每行都是一个用户对所有物品的打分：

# 示例数据：用户-物品评分矩阵
ratings_matrix = np.array([
    [4, 0, 0, 5, 1],
    [5, 5, 4, 0, 0],
    [0, 0, 5, 4, 0],
    [5, 4, 4, 0, 0],
    [0, 0, 0, 5, 4]
])

我们想要得到用户0的推荐产品：

# 初始化并使用User-based CF模型
user_cf = UserBasedCF(ratings_matrix, k=2)

# 为用户0推荐物品
recommendations = user_cf.recommend(0, num_recommendations=2)
print(f"Recommendations for user 0: {recommendations}")

# 预测用户0对物品1的评分
predicted_rating = user_cf.predict_rating(0, 1)
print(f"Predicted rating for user 0 on item 1: {predicted_rating:.2f}")

首先实例化模型，需要计算用户相似度。这个相似度被保存在user_cf.user_similarity变量中：

user_cf.user_similarity 

array([[1.        , 0.37986859, 0.48196269, 0.40875956, 0.6988459 ],
       [0.37986859, 1.        , 0.38447322, 0.99453584, 0.        ],
       [0.48196269, 0.38447322, 1.        , 0.4137144 , 0.48780488],
       [0.40875956, 0.99453584, 0.4137144 , 1.        , 0.        ],
       [0.6988459 , 0.        , 0.48780488, 0.        , 1.        ]])

输出是一个共轭矩阵，可以看到用户0和用户2/用户4的相似度最高。

现在我们想找到对用户0的2个推荐物品。首先需要找到用户评分的物品和未评分的物品：

user_ratings = self.ratings[user_index]
# 用户0的评分：[4 0 0 5 1]
item_indices = np.where(user_ratings == 0)[0]
# 用户0未评分的物品：[1 2]

现在就需要对用户0未评分的物品进行预测打分，来判断用户是否会喜欢。

要进行打分，就需要找到用户最相似的k个用户。这里k设置为2。根据前面计算得到相似用户是2和4。随后根据用户2，4对物品1，2的打分预测目标用户的打分。

我们需要遍历每个邻居，找到当前邻居对需要计算的物品的打分。如果分数不为0，则将分子设为用户相似度*用户对物品评分的加和，而分母设置为用户相似度的绝对值之和（用于归一化分子的加权和），最后得到的预测得分是相似用户的评分的加权得分。

分母设置为相似度的绝对值之和是为了防止出现负数之后使得分母为0。

示例

假设用户$u$的相似邻居 $Nu$有以下相似度和评分：

用户 $v$	相似度 $s(u,v)$	评分 $r_{vi}$
用户 1	0.9	4
用户 2	-0.8	3
用户 3	0.7	5

计算预测评分：

分子：$(0.9×4)+(−0.8×3)+(0.7×5)=3.6−2.4+3.5=4.7$
分母：$∣0.9∣+∣−0.8∣+∣0.7∣=0.9+0.8+0.7=2.4$
预测得分：$\frac{2.4}{4.7}≈1.96$

UserCF的不足

UserCF存在一些不足：

物体过多导致的稀疏矩阵问题，很多用户可能接触不到百分之一的物品。
用户增长比物品增长快的时候需要频繁维护相似度矩阵，对存储要求非常大，尤其是高用户的场景。

基于物品的协同过滤

相比UserCF，ItemCF被工业界应用的更多，例如此前亚马逊，Netflix和Youtube都使用过它。例如在电商平台某个商品下，会推荐类似商品，或者购买此商品的用户还看过这样的标签。背后用的就是ItemCF。

流程与UserCF类似。基本思想是根据用户的历史偏好数据计算物品之间的相似性，然后把与用户喜欢的物品相类似的物品推荐给用户。比如物品A和C非常相似，因为喜欢A的用户同时也喜欢C，而用户甲喜欢A，所以把C推荐给用户甲。

一言概况：喜欢某个物品的用户，也可能喜欢和该物品类似的物品。举一个例子：

	Item 1	Item 2	Item 3	Item 4	Item 5
User 1	5	3	4	4
User 2	3	1	2	3	3
User 3	4	3	4	3	5
User 4	3	3	1	5	4

现在我们想预测User 1对Item 5的打分，就需要：

计算Item 5和其他Item的相似度
找到和Item 5最相近的k个物品
根据User 1和最相近的k个物品的打分计算Item 5的得分

示例代码和之前类似：

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

class ItemBasedCF:
    def __init__(self, ratings, k=5):
        self.ratings = ratings
        self.k = k
        self.item_similarity = self.calculate_item_similarity()

    def calculate_item_similarity(self):
        return cosine_similarity(self.ratings.T)

    def predict_rating(self, user_index, item_index):
        similar_items = np.argsort(self.item_similarity[item_index])[-(self.k+1):]
        similar_items = similar_items[similar_items != item_index]
        
        numerator = 0
        denominator = 0
        
        for neighbor in similar_items:
            if self.ratings[user_index, neighbor] > 0:
                numerator += self.item_similarity[item_index, neighbor] * self.ratings[user_index, neighbor]
                denominator += abs(self.item_similarity[item_index, neighbor])
        
        if denominator == 0:
            return 0
        else:
            return numerator / denominator

    def recommend(self, user_index, num_recommendations=5):
        user_ratings = self.ratings[user_index]
        item_indices = np.where(user_ratings == 0)[0]
        
        predictions = np.array([self.predict_rating(user_index, item) for item in item_indices])
        recommended_items = item_indices[np.argsort(predictions)[-num_recommendations:]]
        
        return recommended_items

同样的，先计算物品相似度：

item_cf.item_similarity

array([[1.        , 0.86506475, 0.65215465, 0.3030303 , 0.11941629],
       [0.86506475, 1.        , 0.74468592, 0.        , 0.        ],
       [0.65215465, 0.74468592, 1.        , 0.32607733, 0.        ],
       [0.3030303 , 0.        , 0.32607733, 1.        , 0.74635179],
       [0.11941629, 0.        , 0.        , 0.74635179, 1.        ]])

可以看到Item 5和Item 4最相似。随后计算得分的时候，分母是最相似的物品的用户打分*相似度，分母同样是相似度的绝对值加和。

工业离线计算的技巧

在实际工业中，如果要计算完整的物品相似度，计算量过大，因此需要用一些trick。通过将余弦相似度公式展开后发现，只有当用户A对需要对比的两个物品都打分时，相似度才不为0。因此在计算时需要对这些稀疏数据进行过滤。

协同过滤的问题

协同过滤的经典问题就是稀疏性问题，由于超过百分之80的数据都可能是Nan，数据质量并不好。

另一个问题是无法捕捉到物品本身的信息，仅仅使用了用户与物品的交互信息，而放弃了用户特征，物品特征，为了解决这个问题，工业界逐渐转向了使用逻辑回归之流的算法。

此外，热门的物品会和大量其他的物品出现相似性，这不是因为它们本身相似，只是因为它经常被购买。为了解决这个问题，出现了MF算法，使用隐向量表示物品。

第三个问题就是冷启动问题，对于没有历史信息的用户，找不到相似的用户进行推荐。

为了解决这几个问题，需要对一些热门物品进行惩罚，例如对热门商品或者活跃用户进行惩罚。

什么时候用UserCF/ItemCF？

摘抄一下：

UserCF 由于是基于用户相似度进行推荐，所以具备更强的社交特性，这样的特点非常适于用户少，物品多，时效性较强的场合，比如新闻推荐场景，因为新闻本身兴趣点分散，相比用户对不同新闻的兴趣偏好，新闻的及时性，热点性往往更加重要，所以正好适用于发现热点，跟踪热点的趋势。另外还具有推荐新信息的能力，更有可能发现惊喜, 因为看的是人与人的相似性, 推出来的结果可能更有惊喜，可以发现用户潜在但自己尚未察觉的兴趣爱好。

对于用户较少，要求时效性较强的场合，就可以考虑UserCF。
ItemCF 这个更适用于兴趣变化较为稳定的应用，更接近于个性化的推荐，适合物品少，用户多，用户兴趣固定持久，物品更新速度不是太快的场合，比如推荐艺术品，音乐，电影。

2024/7/28 于苏州

推荐系统

#推荐系统

推荐系统：Swing-基于ItemCF的改进上一篇

SyncTV+AList+阿里云盘搭建服务器同步观影影院下一篇